TowerDefense/Assets/VoxelImporter/Scripts/Editor/VoxelEditorCommon.cs

#define PreviewObjectHide

using UnityEngine;
using UnityEngine.Assertions;
using UnityEditor;
using System;
using System.IO;
using System.Collections.Generic;

namespace VoxelImporter
{
    public class VoxelEditorCommon
    {
        public VoxelBase objectTarget { get; private set; }
        public VoxelBaseCore objectCore { get; private set; }

        public Material vertexColorMaterial { get; private set; }
        public Material vertexColorTransparentMaterial { get; private set; }
        public Material vertexColorTransparentZwriteMaterial { get; private set; }
        public Material unlitColorMaterial { get; private set; }
        public Material unlitTextureMaterial { get; private set; }
        public Texture2D blackTransparentTexture { get; private set; }
        public List<Rect> editorRectList { get; private set; }

        #region GUIStyle
        public GUIStyle guiStyleAlphaBox { get; private set; }
        public GUIStyle guiStyleToggleLeft { get; private set; }
        public GUIStyle guiStyleToggleRight { get; private set; }
        public GUIStyle guiStyleLabel { get; private set; }
        public GUIStyle guiStyleActiveButton { get; private set; }
        #endregion

        //Animation
        private float animationTime;
        public float AnimationPower { get { return 1f - ((Mathf.Cos((Time.realtimeSinceStartup - animationTime) * Mathf.PI * 2f) + 1f) / 2f); } }

        #region SelectionRect
        public struct SelectionRect
        {
            public void Reset()
            {
                Enable = false;
                start = IntVector2.zero;
                end = IntVector2.zero;
            }
            public void SetStart(IntVector2 add)
            {
                Enable = true;
                start = add;
                end = add;
            }
            public void SetEnd(IntVector2 add)
            {
                end = add;
            }
            public bool Enable { get; private set; }
            public int SizeX { get { return max.x - min.x + 1; } }
            public int SizeY { get { return max.y - min.y + 1; } }
            public IntVector2 min { get { return IntVector2.Min(start, end); } }
            public IntVector2 max { get { return IntVector2.Max(start, end); } }
            public Rect rect { get { return new Rect(min.x, min.y, max.x - min.x, max.y - min.y); } }

            public IntVector2 start;
            public IntVector2 end;
        }
        public SelectionRect selectionRect;
        #endregion

        //Tool
        public static Tool lastTool;

        //Fill
        public long fillVoxelDataLastTimeTicks;
        public DataTable3<List<IntVector3>> fillVoxelTable;
        public DataTable3<VoxelData.FaceAreaTable> fillVoxelFaceAreaTable;
        public DataTable3<Dictionary<int, List<IntVector3>>> fillVoxelFaceTable;
        public DataTable3<Dictionary<int, VoxelData.FaceAreaTable>> fillVoxelFaceFaceAreaTable;

        //Mesh
        public Mesh[] silhouetteMesh;
        public Mesh[] previewMesh;
        public Mesh[] cursorMesh;

        #region Icon
        public GameObject iconRoot;
        public RenderTexture iconTexture;
        public GameObject iconModel;
        public MeshRenderer iconModelRenderer;
        public GameObject iconCamera;
        public Camera iconCameraCamera;
        #endregion

        public VoxelEditorCommon(VoxelBase objectTarget, VoxelBaseCore objectCore)
        {
            this.objectTarget = objectTarget;
            this.objectCore = objectCore;

            vertexColorMaterial = new Material(Shader.Find("Voxel Importer/VertexColor"));
            vertexColorMaterial.hideFlags = HideFlags.DontSave;

            vertexColorTransparentMaterial = new Material(Shader.Find("Voxel Importer/VertexColor-Transparent"));
            vertexColorTransparentMaterial.hideFlags = HideFlags.DontSave;

            vertexColorTransparentZwriteMaterial = new Material(Shader.Find("Voxel Importer/VertexColor-Transparent-Zwrite"));
            vertexColorTransparentZwriteMaterial.hideFlags = HideFlags.DontSave;

            unlitColorMaterial = new Material(Shader.Find("Voxel Importer/Unlit/Color"));
            unlitColorMaterial.hideFlags = HideFlags.DontSave;

            unlitTextureMaterial = new Material(Shader.Find("Voxel Importer/Unlit/Transparent"));
            unlitTextureMaterial.hideFlags = HideFlags.DontSave;

            blackTransparentTexture = CreateColorTexture(new Color(0, 0, 0, 0.3f));

            editorRectList = new List<Rect>();

            animationTime = Time.realtimeSinceStartup;
        }

        public void ClearCache()
        {
            ClearSilhouetteMeshMesh();
            ClearPreviewMesh();
            ClearCursorMesh();

            fillVoxelTable = null;
            fillVoxelFaceAreaTable = null;
            fillVoxelFaceTable = null;
            fillVoxelFaceFaceAreaTable = null;
        }

        public Texture2D CreateColorTexture(Color color)
        {
            Texture2D tex = new Texture2D(4, 4);
            tex.hideFlags = HideFlags.DontSave;
            for (int x = 0; x < tex.width; x++)
            {
                for (int y = 0; y < tex.height; y++)
                {
                    tex.SetPixel(x, y, color);
                }
            }
            tex.Apply();
            return tex;
        }

        public Texture2D LoadTexture2DAssetAtPath(string path)
        {
            var result = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
            if (result == null)
            {
                var fileName = Path.GetFileName(path);
                var guids = AssetDatabase.FindAssets("t:Texture2D");
                for (int i = 0; i < guids.Length; i++)
                {
                    var assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
                    if (Path.GetFileName(assetPath) == fileName)
                    {
                        if (assetPath.IndexOf("VoxelImporter") >= 0)
                        {
                            result = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
                            break;
                        }
                    }
                }
            }
            return result;
        }

        public void ClearSilhouetteMeshMesh()
        {
            if (silhouetteMesh != null)
            {
                for (int i = 0; i < silhouetteMesh.Length; i++)
                {
                    MonoBehaviour.DestroyImmediate(silhouetteMesh[i]);
                }
                silhouetteMesh = null;
            }
        }
        public void ClearPreviewMesh()
        {
            if (previewMesh != null)
            {
                for (int i = 0; i < previewMesh.Length; i++)
                {
                    MonoBehaviour.DestroyImmediate(previewMesh[i]);
                }
                previewMesh = null;
            }
        }
        public void ClearCursorMesh()
        {
            if (cursorMesh != null)
            {
                for (int i = 0; i < cursorMesh.Length; i++)
                {
                    MonoBehaviour.DestroyImmediate(cursorMesh[i]);
                }
                cursorMesh = null;
            }
        }

        public bool CheckMousePositionEditorRects()
        {
            for (int i = 0; i < editorRectList.Count; i++)
            {
                if (editorRectList[i].Contains(Event.current.mousePosition))
                {
                    return false;
                }
            }
            return true;
        }

        public IntVector3? GetMousePositionVoxel()
        {
            IntVector3? result = null;

            if (objectCore.voxelData == null || objectTarget.voxelData.voxels == null)
                return result;
            if (!CheckMousePositionEditorRects())
                return result;

            Ray localRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
            {
                Matrix4x4 mat = objectTarget.transform.worldToLocalMatrix;
                localRay.direction = mat.MultiplyVector(localRay.direction);
                localRay.origin = mat.MultiplyPoint(localRay.origin);
            }

            {
                var boundsBase = objectCore.GetVoxelBounds(IntVector3.zero);
                float lengthMin = float.MaxValue;
                for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
                {
                    if (objectTarget.voxelData.voxels[i].visible == 0)
                        continue;

                    Vector3 position = new Vector3(objectTarget.voxelData.voxels[i].x, objectTarget.voxelData.voxels[i].y, objectTarget.voxelData.voxels[i].z);
                    Vector3 offset = Vector3.Scale(position, objectTarget.importScale);
                    var bounds = boundsBase;
                    bounds.center += offset;
                    float length;
                    if (bounds.IntersectRay(localRay, out length))
                    {
                        if (!result.HasValue || length < lengthMin)
                        {
                            result = objectTarget.voxelData.voxels[i].position;
                            lengthMin = length;
                        }
                    }
                }
            }

            return result;
        }

        public bool GetMousePositionVoxelFace(out IntVector3 result, out VoxelBase.Face face)
        {
            result = IntVector3.zero;
            face = 0;

            if (objectCore.voxelData == null || objectTarget.voxelData.voxels == null)
                return false;
            if (!CheckMousePositionEditorRects())
                return false;

            Ray localRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
            {
                Matrix4x4 mat = objectTarget.transform.worldToLocalMatrix;
                localRay.direction = mat.MultiplyVector(localRay.direction);
                localRay.origin = mat.MultiplyPoint(localRay.origin);
            }

            {
                var boundsBase = objectCore.GetVoxelBounds(IntVector3.zero);
                float lengthMin = float.MaxValue;
                for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
                {
                    if (objectTarget.voxelData.voxels[i].visible == 0)
                        continue;

                    Vector3 position = new Vector3(objectTarget.voxelData.voxels[i].x, objectTarget.voxelData.voxels[i].y, objectTarget.voxelData.voxels[i].z);
                    Vector3 offset = Vector3.Scale(position, objectTarget.importScale);
                    var bounds = boundsBase;
                    bounds.center += offset;
                    float length;
                    if (bounds.IntersectRay(localRay, out length))
                    {
                        if (length < lengthMin)
                        {
                            result = objectTarget.voxelData.voxels[i].position;
                            lengthMin = length;
                            #region Face
                            {
                                const float Threshold = 0.001f;
                                var posP = localRay.GetPoint(length);
                                if (Mathf.Abs(bounds.min.x - posP.x) < Threshold)
                                    face = VoxelBase.Face.left;
                                else if (Mathf.Abs(bounds.max.x - posP.x) < Threshold)
                                    face = VoxelBase.Face.right;
                                else if (Mathf.Abs(bounds.min.y - posP.y) < Threshold)
                                    face = VoxelBase.Face.down;
                                else if (Mathf.Abs(bounds.max.y - posP.y) < Threshold)
                                    face = VoxelBase.Face.up;
                                else if (Mathf.Abs(bounds.min.z - posP.z) < Threshold)
                                    face = VoxelBase.Face.back;
                                else if (Mathf.Abs(bounds.max.z - posP.z) < Threshold)
                                    face = VoxelBase.Face.forward;
                                else
                                    Assert.IsTrue(false);
                            }
                            #endregion
                        }
                    }
                }
            }

            return face != 0;
        }

        private void CheckFillVoxelTableCheck()
        {
            if (fillVoxelDataLastTimeTicks != objectTarget.voxelData.updateVoxelTableLastTimeTicks)
            {
                fillVoxelTable = null;
                fillVoxelFaceAreaTable = null;
                fillVoxelFaceTable = null;
                fillVoxelFaceFaceAreaTable = null;
                fillVoxelDataLastTimeTicks = objectTarget.voxelData.updateVoxelTableLastTimeTicks;
            }
        }
        public List<IntVector3> GetFillVoxel(IntVector3 pos)
        {
            if (objectTarget.voxelData == null) return null;
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0) return null;

            CheckFillVoxelTableCheck();
            if (fillVoxelTable == null)
            {
                fillVoxelTable = new DataTable3<List<IntVector3>>(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelTable.Contains(pos))
            {
                List<IntVector3> searchList = new List<IntVector3>();
                int posPalette = 0;
                var doneTable = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
                {
                    var index = objectTarget.voxelData.VoxelTableContains(pos);
                    posPalette = objectTarget.voxelData.voxels[index].palette;
                    searchList.Clear();
                    searchList.Add(pos);
                    doneTable.Set(pos, true);
                }
                var result = new List<IntVector3>();
                for (int j = 0; j < searchList.Count; j++)
                {
                    var p = searchList[j];
                    var index = objectTarget.voxelData.VoxelTableContains(p);
                    if (index < 0) continue;
                    if (objectTarget.voxelData.voxels[index].palette == posPalette)
                    {
                        result.Add(p);
                        for (int x = p.x - 1; x <= p.x + 1; x++)
                        {
                            for (int y = p.y - 1; y <= p.y + 1; y++)
                            {
                                for (int z = p.z - 1; z <= p.z + 1; z++)
                                {
                                    if (x >= 0 && y >= 0 && z >= 0 &&
                                        x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
                                        !doneTable.Get(x, y, z))
                                    {
                                        doneTable.Set(x, y, z, true);
                                        var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
                                        if (indexTmp >= 0 && objectTarget.voxelData.voxels[indexTmp].palette == posPalette)
                                            searchList.Add(new IntVector3(x, y, z));
                                    }
                                }
                            }
                        }
                    }
                }

                for (int j = 0; j < result.Count; j++)
                {
                    fillVoxelTable.Set(result[j], result);
                }
            }
            var fillVoxel = fillVoxelTable.Get(pos);

            return fillVoxel;
        }
        public VoxelData.FaceAreaTable GetFillVoxelFaceAreaTable(IntVector3 pos)
        {
            if (objectTarget.voxelData == null) return null;
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0) return null;

            CheckFillVoxelTableCheck();
            if (fillVoxelFaceAreaTable == null)
            {
                fillVoxelFaceAreaTable = new DataTable3<VoxelData.FaceAreaTable>(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelFaceAreaTable.Contains(pos))
            {
                var list = GetFillVoxel(pos);
                if (list == null) return null;
                var voxels = new List<VoxelData.Voxel>();
                for (int i = 0; i < list.Count; i++)
                {
                    var index = objectTarget.voxelData.VoxelTableContains(list[i]);
                    var voxel = objectTarget.voxelData.voxels[index];
                    voxel.palette = -1;
                    voxels.Add(voxel);
                }
                var faceAreaTable = objectCore.Edit_CreateMeshOnly_FaceArea(voxels, true);
                for (int i = 0; i < list.Count; i++)
                {
                    fillVoxelFaceAreaTable.Set(list[i], faceAreaTable);
                }
            }
            var fillVoxelFaceArea = fillVoxelFaceAreaTable.Get(pos);

            return fillVoxelFaceArea;
        }
        public List<IntVector3> GetFillVoxelFace(IntVector3 pos, VoxelBase.Face face)
        {
            if (objectTarget.voxelData == null) return null;
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0) return null;

            CheckFillVoxelTableCheck();
            if (fillVoxelFaceTable == null)
            {
                fillVoxelFaceTable = new DataTable3<Dictionary<int, List<IntVector3>>>(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelFaceTable.Contains(pos) ||
                !fillVoxelFaceTable.Get(pos).ContainsKey((int)face))
            {
                List<IntVector3> searchList = new List<IntVector3>();
                var doneTable = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
                {
                    searchList.Clear();
                    searchList.Add(pos);
                    doneTable.Set(pos, true);
                }
                var result = new List<IntVector3>();
                for (int j = 0; j < searchList.Count; j++)
                {
                    var p = searchList[j];
                    var index = objectTarget.voxelData.VoxelTableContains(p);
                    if (index < 0) continue;
                    if ((objectTarget.voxelData.voxels[index].visible & face) != 0)
                    {
                        result.Add(p);
                        int xOffset = (face & (VoxelBase.Face.up | VoxelBase.Face.down | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
                        int yOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
                        int zOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.up | VoxelBase.Face.down)) != 0 ? 1 : 0;
                        for (int x = p.x - xOffset; x <= p.x + xOffset; x++)
                        {
                            for (int y = p.y - yOffset; y <= p.y + yOffset; y++)
                            {
                                for (int z = p.z - zOffset; z <= p.z + zOffset; z++)
                                {
                                    if (x >= 0 && y >= 0 && z >= 0 &&
                                        x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
                                        !doneTable.Get(x, y, z))
                                    {
                                        doneTable.Set(x, y, z, true);
                                        var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
                                        if (indexTmp >= 0)
                                            searchList.Add(new IntVector3(x, y, z));
                                    }
                                }
                            }
                        }
                    }
                }

                Dictionary<int, List<IntVector3>> data;
                if (fillVoxelFaceTable.Contains(pos))
                    data = fillVoxelFaceTable.Get(pos);
                else
                    data = new Dictionary<int, List<IntVector3>>();
                data[(int)face] = result;
                fillVoxelFaceTable.Set(pos, data);
                for (int j = 0; j < result.Count; j++)
                {
                    if (fillVoxelFaceTable.Contains(result[j]))
                        data = fillVoxelFaceTable.Get(result[j]);
                    else
                        data = new Dictionary<int, List<IntVector3>>();
                    data[(int)face] = result;
                    fillVoxelFaceTable.Set(result[j], data);
                }
            }
            var fillVoxel = fillVoxelFaceTable.Get(pos)[(int)face];

            return fillVoxel;
        }
        public VoxelData.FaceAreaTable GetFillVoxelFaceFaceAreaTable(IntVector3 pos, VoxelBase.Face face)
        {
            if (objectTarget.voxelData == null) return null;
            if (objectTarget.voxelData.VoxelTableContains(pos) < 0) return null;

            CheckFillVoxelTableCheck();
            if (fillVoxelFaceFaceAreaTable == null)
            {
                fillVoxelFaceFaceAreaTable = new DataTable3<Dictionary<int, VoxelData.FaceAreaTable>>(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
            }
            if (!fillVoxelFaceFaceAreaTable.Contains(pos) ||
                !fillVoxelFaceFaceAreaTable.Get(pos).ContainsKey((int)face))
            {
                var list = GetFillVoxelFace(pos, face);
                if (list == null) return null;
                var voxels = new List<VoxelData.Voxel>();
                for (int i = 0; i < list.Count; i++)
                {
                    var index = objectTarget.voxelData.VoxelTableContains(list[i]);
                    var voxel = objectTarget.voxelData.voxels[index];
                    voxel.palette = -1;
                    voxel.visible = face;
                    voxels.Add(voxel);
                }
                var faceAreaTable = objectCore.Edit_CreateMeshOnly_FaceArea(voxels, true);

                Dictionary<int, VoxelData.FaceAreaTable> data;
                if (fillVoxelFaceFaceAreaTable.Contains(pos))
                    data = fillVoxelFaceFaceAreaTable.Get(pos);
                else
                    data = new Dictionary<int, VoxelData.FaceAreaTable>();
                data[(int)face] = faceAreaTable;
                fillVoxelFaceFaceAreaTable.Set(pos, data);
                for (int i = 0; i < list.Count; i++)
                {
                    if (fillVoxelFaceFaceAreaTable.Contains(list[i]))
                        data = fillVoxelFaceFaceAreaTable.Get(list[i]);
                    else
                        data = new Dictionary<int, VoxelData.FaceAreaTable>();
                    data[(int)face] = faceAreaTable;
                    fillVoxelFaceFaceAreaTable.Set(list[i], data);
                }
            }
            var fillVoxelFaceArea = fillVoxelFaceFaceAreaTable.Get(pos)[(int)face];

            return fillVoxelFaceArea;
        }

        public struct VertexPower
        {
            public IntVector3 position;
            public float power;
        }
        public List<VertexPower> GetMousePositionVertex(float radius)
        {
            List<VertexPower> result = new List<VertexPower>();
            if (objectTarget.voxelData == null || objectTarget.voxelData.voxels == null)
                return result;
            if (!CheckMousePositionEditorRects())
                return result;

            var boundsList = new List<Bounds>();
            var vertexList = new List<VertexPower>();
            {
                Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
                ray.origin = objectTarget.transform.worldToLocalMatrix.MultiplyPoint3x4(ray.origin);
                ray.direction = objectTarget.transform.worldToLocalMatrix.MultiplyVector(ray.direction);
                bool[,,] doneTable = new bool[objectTarget.voxelData.voxelSize.x + 1, objectTarget.voxelData.voxelSize.y + 1, objectTarget.voxelData.voxelSize.z + 1];
                {
                    Ray rayRadius = HandleUtility.GUIPointToWorldRay(new Vector2(Event.current.mousePosition.x + radius, Event.current.mousePosition.y));
                    rayRadius.origin = objectTarget.transform.worldToLocalMatrix.MultiplyPoint3x4(rayRadius.origin);
                    rayRadius.direction = objectTarget.transform.worldToLocalMatrix.MultiplyVector(rayRadius.direction);

                    Func<IntVector3, bool> AddVertex = (pos) =>
                    {
                        if (doneTable[pos.x, pos.y, pos.z])
                            return true;
                        doneTable[pos.x, pos.y, pos.z] = true;

                        var posL = objectCore.GetVoxelRatePosition(pos, Vector3.zero);
                        var posP = ray.origin + ray.direction * Vector3.Dot(posL - ray.origin, ray.direction);
                        var posR = rayRadius.origin + rayRadius.direction * (Vector3.Dot(posP - rayRadius.origin, rayRadius.direction));
                        var distanceL = (posL - posP).sqrMagnitude;
                        var distanceR = (posR - posP).sqrMagnitude;
                        if (distanceL < distanceR)
                        {
                            vertexList.Add(new VertexPower() { position = pos, power = distanceL / distanceR });
                            return true;
                        }
                        return false;
                    };
                    for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
                    {
                        if (objectTarget.voxelData.voxels[i].visible == 0) continue;

                        var pos = objectTarget.voxelData.voxels[i].position;
                        bool enable = false;

                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.left | VoxelBase.Face.down | VoxelBase.Face.back)) != 0)
                            if (AddVertex(new IntVector3(pos.x, pos.y, pos.z))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.right | VoxelBase.Face.down | VoxelBase.Face.back)) != 0)
                            if (AddVertex(new IntVector3(pos.x + 1, pos.y, pos.z))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.left | VoxelBase.Face.up | VoxelBase.Face.back)) != 0)
                            if (AddVertex(new IntVector3(pos.x, pos.y + 1, pos.z))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.left | VoxelBase.Face.down | VoxelBase.Face.forward)) != 0)
                            if (AddVertex(new IntVector3(pos.x, pos.y, pos.z + 1))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.right | VoxelBase.Face.up | VoxelBase.Face.back)) != 0)
                            if (AddVertex(new IntVector3(pos.x + 1, pos.y + 1, pos.z))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.right | VoxelBase.Face.down | VoxelBase.Face.forward)) != 0)
                            if (AddVertex(new IntVector3(pos.x + 1, pos.y, pos.z + 1))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.left | VoxelBase.Face.up | VoxelBase.Face.forward)) != 0)
                            if (AddVertex(new IntVector3(pos.x, pos.y + 1, pos.z + 1))) enable = true;
                        if ((objectTarget.voxelData.voxels[i].visible & (VoxelBase.Face.right | VoxelBase.Face.up | VoxelBase.Face.forward)) != 0)
                            if (AddVertex(new IntVector3(pos.x + 1, pos.y + 1, pos.z + 1))) enable = true;
                        if (enable)
                        {
                            if ((ray.direction.x < 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.right) != 0)) ||
                                (ray.direction.x > 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.left) != 0)) ||
                                (ray.direction.y < 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.up) != 0)) ||
                                (ray.direction.y > 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.down) != 0)) ||
                                (ray.direction.z < 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.forward) != 0)) ||
                                (ray.direction.z > 0f && ((objectTarget.voxelData.voxels[i].visible & VoxelBase.Face.back) != 0)))
                            {
                                boundsList.Add(objectCore.GetVoxelBounds(pos));
                            }
                        }
                    }
                }
            }

            {
                for (int i = 0; i < vertexList.Count; i++)
                {
                    var pos = objectCore.GetVoxelRatePosition(vertexList[i].position, Vector3.zero);
                    Ray ray = HandleUtility.GUIPointToWorldRay(HandleUtility.WorldToGUIPoint(objectTarget.transform.localToWorldMatrix.MultiplyPoint3x4(pos)));
                    ray.origin = objectTarget.transform.worldToLocalMatrix.MultiplyPoint3x4(ray.origin);
                    ray.direction = objectTarget.transform.worldToLocalMatrix.MultiplyVector(ray.direction);
                    float length = (pos - ray.origin).magnitude - 0.1f;
                    bool enable = true;
                    for (int j = 0; j < boundsList.Count; j++)
                    {
                        float distance;
                        if (boundsList[j].IntersectRay(ray, out distance))
                        {
                            if (distance < length)
                            {
                                enable = false;
                                break;
                            }
                        }
                    }
                    if (enable)
                    {
                        result.Add(vertexList[i]);
                    }
                }
            }

            return result;
        }

        public List<IntVector3> GetSelectionRectVoxel()
        {
            List<IntVector3> result = new List<IntVector3>();
            if (selectionRect.Enable &&
                objectTarget.voxelData != null && objectTarget.voxelData.voxels != null)
            {
                var localToWorldMatrix = objectTarget.transform.localToWorldMatrix;
                for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
                {
                    var local = objectCore.GetVoxelCenterPosition(objectTarget.voxelData.voxels[i].position);
                    var world = localToWorldMatrix.MultiplyPoint(local);
                    var screen = HandleUtility.WorldToGUIPoint(world);
                    if (selectionRect.rect.Contains(screen))
                    {
                        result.Add(objectTarget.voxelData.voxels[i].position);
                    }
                }
            }
            return result;
        }
        public Dictionary<IntVector3, VoxelBase.Face> GetSelectionRectVoxelFace()
        {
            Dictionary<IntVector3, VoxelBase.Face> result = new Dictionary<IntVector3, VoxelBase.Face>();
            if (selectionRect.Enable &&
                objectTarget.voxelData != null && objectTarget.voxelData.vertexList != null)
            {
                var localToWorldMatrix = objectTarget.transform.localToWorldMatrix;
                FlagTable3 containsTable = new FlagTable3(objectTarget.voxelData.voxelSize.x + 1, objectTarget.voxelData.voxelSize.y + 1, objectTarget.voxelData.voxelSize.z + 1);
                for (int i = 0; i < objectTarget.voxelData.vertexList.Count; i++)
                {
                    var local = objectCore.GetVoxelRatePosition(objectTarget.voxelData.vertexList[i], Vector3.zero);
                    var world = localToWorldMatrix.MultiplyPoint3x4(local);
                    var screen = HandleUtility.WorldToGUIPoint(world);
                    if (selectionRect.rect.Contains(screen))
                        containsTable.Set(objectTarget.voxelData.vertexList[i], true);
                }
                containsTable.AllAction((x, y, z) =>
                {
                    Action<int, int, int, VoxelBase.Face> AddFace = (xx, yy, zz, face) =>
                    {
                        var pos = new IntVector3(xx, yy, zz);
                        var index = objectTarget.voxelData.VoxelTableContains(pos);
                        if (index < 0) return;
                        if ((objectTarget.voxelData.voxels[index].visible & face) == 0) return;

                        VoxelBase.Face combineFace;
                        if (!result.TryGetValue(pos, out combineFace))
                        {
                            result.Add(pos, face);
                        }
                        else
                        {
                            combineFace |= face;
                            result[pos] = combineFace;
                        }
                    };
                    #region Left
                    if (containsTable.Get(x, y + 1, z) &&
                        containsTable.Get(x, y, z + 1) &&
                        containsTable.Get(x, y + 1, z + 1))
                    {
                        AddFace(x, y, z, VoxelBase.Face.left);
                        AddFace(x - 1, y, z, VoxelBase.Face.right);
                    }
                    #endregion
                    #region Down
                    if (containsTable.Get(x + 1, y, z) &&
                        containsTable.Get(x, y, z + 1) &&
                        containsTable.Get(x + 1, y, z + 1))
                    {
                        AddFace(x, y, z, VoxelBase.Face.down);
                        AddFace(x, y - 1, z, VoxelBase.Face.up);
                    }
                    #endregion
                    #region Back
                    if (containsTable.Get(x + 1, y, z) &&
                        containsTable.Get(x, y + 1, z) &&
                        containsTable.Get(x + 1, y + 1, z))
                    {
                        AddFace(x, y, z, VoxelBase.Face.back);
                        AddFace(x, y, z - 1, VoxelBase.Face.forward);
                    }
                    #endregion
                });
            }
            return result;
        }
        public List<IntVector3> GetSelectionRectVertex()
        {
            List<IntVector3> result = new List<IntVector3>();
            if (selectionRect.Enable &&
                objectTarget.voxelData != null && objectTarget.voxelData.vertexList != null)
            {
                var localToWorldMatrix = objectTarget.transform.localToWorldMatrix;
                for (int i = 0; i < objectTarget.voxelData.vertexList.Count; i++)
                {
                    var local = objectCore.GetVoxelRatePosition(objectTarget.voxelData.vertexList[i], Vector3.zero);
                    var world = localToWorldMatrix.MultiplyPoint3x4(local);
                    var screen = HandleUtility.WorldToGUIPoint(world);
                    if (selectionRect.rect.Contains(screen))
                    {
                        result.Add(objectTarget.voxelData.vertexList[i]);
                    }
                }
            }
            return result;
        }

        public Rect ResizeSceneViewRect(Rect rect)
        {
            var sv = SceneView.currentDrawingSceneView;
            if (rect.x + rect.width >= sv.position.width)
                rect.x -= (rect.x + rect.width) - sv.position.width;
            if (rect.y + rect.height >= sv.position.height)
                rect.y -= (rect.y + rect.height) - sv.position.height;
            if (rect.x < 0)
                rect.x -= rect.x;
            if (rect.y < 0)
                rect.y -= rect.y;
            return rect;
        }

        public void GUIStyleReady()
        {
            if (guiStyleAlphaBox == null)
                guiStyleAlphaBox = new GUIStyle(GUI.skin.box);
            guiStyleAlphaBox.normal.textColor = Color.white;
            guiStyleAlphaBox.fontStyle = FontStyle.Bold;
            guiStyleAlphaBox.alignment = TextAnchor.UpperCenter;
            guiStyleAlphaBox.normal.background = blackTransparentTexture;
            if (guiStyleToggleLeft == null)
                guiStyleToggleLeft = new GUIStyle(GUI.skin.toggle);
            guiStyleToggleLeft.normal.textColor = Color.white;
            guiStyleToggleLeft.onNormal.textColor = Color.white;
            guiStyleToggleLeft.hover.textColor = Color.white;
            guiStyleToggleLeft.onHover.textColor = Color.white;
            guiStyleToggleLeft.focused.textColor = Color.white;
            guiStyleToggleLeft.onFocused.textColor = Color.white;
            guiStyleToggleLeft.active.textColor = Color.white;
            guiStyleToggleLeft.onActive.textColor = Color.white;
            if (guiStyleToggleRight == null)
                guiStyleToggleRight = new GUIStyle(GUI.skin.toggle);
            guiStyleToggleRight.normal.textColor = Color.white;
            guiStyleToggleRight.onNormal.textColor = Color.white;
            guiStyleToggleRight.hover.textColor = Color.white;
            guiStyleToggleRight.onHover.textColor = Color.white;
            guiStyleToggleRight.focused.textColor = Color.white;
            guiStyleToggleRight.onFocused.textColor = Color.white;
            guiStyleToggleRight.active.textColor = Color.white;
            guiStyleToggleRight.onActive.textColor = Color.white;
            guiStyleToggleRight.padding.left = 2;
            guiStyleToggleRight.overflow.left = -149;
            if (guiStyleLabel == null)
                guiStyleLabel = new GUIStyle(GUI.skin.label);
            guiStyleLabel.normal.textColor = Color.white;
            if (guiStyleActiveButton == null)
                guiStyleActiveButton = new GUIStyle(GUI.skin.button);
            guiStyleActiveButton.normal = guiStyleActiveButton.active;
        }

        #region Icon
        public void InitializeIcon()
        {
            const string IconRootObjectName = "Tmp#VoxelImporterIcon";

            {
                var objects = Resources.FindObjectsOfTypeAll<GameObject>();
                for (int i = 0; i < objects.Length; i++)
                {
                    if (objects[i].name == IconRootObjectName)
                        iconRoot = objects[i];
                }
            }

            if (iconRoot == null)
            {
#if PreviewObjectHide
                iconRoot = UnityEditor.EditorUtility.CreateGameObjectWithHideFlags(IconRootObjectName, HideFlags.HideAndDontSave);
#else
                iconRoot = new GameObject(IconRootObjectName);
                iconRoot.hideFlags = HideFlags.DontSave;
#endif
            }
            iconRoot.SetActive(false);

            int blankLayer;
            for (blankLayer = 31; blankLayer > 0; blankLayer--)
            {
                if (string.IsNullOrEmpty(LayerMask.LayerToName(blankLayer)))
                    break;
            }
            if (blankLayer < 0)
                blankLayer = 31;
            iconRoot.layer = blankLayer;

            iconTexture = new RenderTexture(128, 128, 16, RenderTextureFormat.ARGB32);
            iconTexture.hideFlags = HideFlags.DontSave;
            iconTexture.Create();

            CreateIconObject();
        }

        public void CreateIconObject(Transform transform = null, Mesh mesh = null, Material[] materials = null)
        {
            if (iconRoot == null) return;

            if (transform != null)
            {
                iconRoot.transform.position = transform.position;
                iconRoot.transform.rotation = transform.rotation;
                iconRoot.transform.localScale = Vector3.one;
            }
            else
            {
                iconRoot.transform.position = Vector3.zero;
                iconRoot.transform.rotation = Quaternion.identity;
                iconRoot.transform.localScale = Vector3.one;
            }

            {
                const string IconModelName = "IconModel";

                var iconModelTransform = iconRoot.transform.Find(IconModelName);
                if (iconModelTransform != null)
                    iconModel = iconModelTransform.gameObject;
                if (iconModel == null)
                {
#if PreviewObjectHide
                    iconModel = UnityEditor.EditorUtility.CreateGameObjectWithHideFlags(IconModelName, HideFlags.HideAndDontSave);
#else
                    iconModel = new GameObject(IconModelName);
                    iconModel.hideFlags = HideFlags.DontSave;
#endif
                }
                iconModel.transform.SetParent(iconRoot.transform);
                iconModel.transform.localPosition = new Vector3(0f, 0f, 0f);
                iconModel.layer = iconRoot.layer;
                MeshFilter meshFilter = iconModel.GetComponent<MeshFilter>();
                if (meshFilter == null)
                    meshFilter = iconModel.AddComponent<MeshFilter>();
                meshFilter.sharedMesh = mesh;
                iconModelRenderer = iconModel.GetComponent<MeshRenderer>();
                if (iconModelRenderer == null)
                    iconModelRenderer = iconModel.AddComponent<MeshRenderer>();
                if (materials != null)
                    iconModelRenderer.sharedMaterials = materials;
            }
            {
                const string IconCameraName = "IconCamera";

                var iconCameraTransform = iconRoot.transform.Find(IconCameraName);
                if (iconCameraTransform != null)
                    iconCamera = iconCameraTransform.gameObject;
                if (iconCamera == null)
                {
#if PreviewObjectHide
                    iconCamera = UnityEditor.EditorUtility.CreateGameObjectWithHideFlags(IconCameraName, HideFlags.HideAndDontSave);
#else
                    iconCamera = new GameObject(IconCameraName);
                    iconCamera.hideFlags = HideFlags.DontSave;
#endif
                    iconCameraCamera = iconCamera.AddComponent<Camera>();
                }
                else
                {
                    iconCameraCamera = iconCamera.GetComponent<Camera>();
                }
                iconCamera.transform.SetParent(iconRoot.transform);
                iconCamera.layer = iconRoot.layer;
                if (mesh != null)
                {
                    var rot = Quaternion.AngleAxis(180f, Vector3.up);
                    iconCamera.transform.localRotation = rot;
                    iconCamera.transform.localPosition = mesh.bounds.center + iconCamera.transform.worldToLocalMatrix.MultiplyVector(iconCamera.transform.forward) * mesh.bounds.size.z * 5f;
                }
                else
                {
                    iconCamera.transform.localPosition = Vector3.zero;
                    iconCamera.transform.localRotation = Quaternion.identity;
                }
                iconCameraCamera.orthographic = true;
                if (mesh != null)
                {
                    iconCameraCamera.orthographicSize = Mathf.Max(mesh.bounds.size.x, Mathf.Max(mesh.bounds.size.y, mesh.bounds.size.z)) * 0.6f;
                    iconCameraCamera.farClipPlane = Mathf.Max(mesh.bounds.size.x, Mathf.Max(mesh.bounds.size.y, mesh.bounds.size.z)) * 5f;
                }
                iconCameraCamera.clearFlags = CameraClearFlags.Color;
                iconCameraCamera.backgroundColor = new Color(0f, 0f, 0f, 0f);
                iconCameraCamera.cullingMask = 1 << iconRoot.layer;
                iconCameraCamera.targetTexture = iconTexture;

            }
        }

        public bool IsReadyIcon()
        {
            return iconRoot != null && iconModelRenderer != null && iconModelRenderer.sharedMaterials != null;
        }

        public Texture2D IconObjectRender()
        {
            if (iconRoot == null) return null;

            Texture2D tex = null;

            iconRoot.SetActive(true);
            iconCameraCamera.Render();
            {
                RenderTexture save = RenderTexture.active;
                RenderTexture.active = iconTexture;
                tex = new Texture2D(iconTexture.width, iconTexture.height, TextureFormat.ARGB32, iconTexture.useMipMap);
                tex.hideFlags = HideFlags.DontSave;
                tex.ReadPixels(new Rect(0, 0, iconTexture.width, iconTexture.height), 0, 0);
                tex.Apply();
                RenderTexture.active = save;
            }
            iconRoot.SetActive(false);

            return tex;
        }

        #endregion
    }
}