Push

2023-02-04 22:44:09 +01:00
parent ce32b06864
commit 59c7021388
54 changed files with 4488 additions and 8767 deletions
@@ -0,0 +1,235 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+using System.Linq;
+
+public class MeshMerger : MonoBehaviour
+{
+    [SerializeField] private Transform[] _mergeObjects;
+    [SerializeField] private Transform _meshPivot;
+
+    [Header("Save properties")]
+    [SerializeField] private string _objectName = "MergedObject";
+#if(UNITY_EDITOR)
+    [SerializeField] private bool _saveMesh;
+    [SerializeField] private string _savePath = "Assets/SavedMeshes";
+
+    private MeshSaver _meshSaver = new MeshSaver();
+#endif
+
+    public void Merge()
+    {
+        Transform[] _meshesTransforms = GetTargetTranforms(_mergeObjects).Distinct().ToArray();
+        Mesh[] meshes = new Mesh[_meshesTransforms.Length];
+        meshes = _meshesTransforms.Select(transform => transform.GetComponent<MeshFilter>().sharedMesh).ToArray();
+
+        Vector3[] vertices = new Vector3[0];
+        int[] triangles = new int[0];
+        Vector2[] uv = new Vector2[0];
+        Vector4[] tangents = new Vector4[0];
+        Vector3[] normals = new Vector3[0];
+
+        List<SubMeshInfo> subMeshesInfo = new List<SubMeshInfo>();
+
+        for (int meshIndex = 0; meshIndex < meshes.Length; meshIndex++)
+        {
+            Mesh currentMesh = meshes[meshIndex];
+            Transform currentTransform = _meshesTransforms[meshIndex];
+            Material[] meshMaterials = _meshesTransforms[meshIndex].GetComponent<MeshRenderer>().sharedMaterials;
+            Vector3 meshLocalPosition = currentTransform.position - _meshPivot.position;
+            //Vector3 globalScale = Vector3.Scale(currentTransform.localScale, 
+            //    currentTransform.parent == null ? Vector3.one : GetGlobalScale(currentTransform.parent));
+
+            Vector3 globalScale = GetGlobalScale(currentTransform);
+
+            int subMeshCount = currentMesh.subMeshCount;
+            SubMeshDescriptor[] subMeshDescriptors = new SubMeshDescriptor[subMeshCount];
+            for (int i = 0; i < subMeshCount; i++) subMeshDescriptors[i] = currentMesh.GetSubMesh(i);
+
+            for (int i = 0; i < meshMaterials.Length; i++)
+            {
+                List<Vector3> addedVertices = currentMesh.vertices
+                    .ToList()
+                    .GetRange(subMeshDescriptors[i].firstVertex, subMeshDescriptors[i].vertexCount)
+                    .Select(verticle => RotateAndScaleVerticle(verticle, currentTransform.rotation,
+                    globalScale, Vector3.zero) + meshLocalPosition)
+                    .ToList();
+
+                List<Vector2> addedUV = currentMesh.uv
+                    .ToList()
+                    .GetRange(subMeshDescriptors[i].firstVertex, subMeshDescriptors[i].vertexCount);
+
+                List<Vector4> addedTangents = currentMesh.tangents
+                    .ToList()
+                    .GetRange(subMeshDescriptors[i].firstVertex, subMeshDescriptors[i].vertexCount)
+                    .Select(tangent =>
+                    {
+                        Vector4 result = RotateAndScaleVerticle(tangent, currentTransform.rotation, Vector3.one, Vector3.zero);
+                        result.w = tangent.w;
+                        return result;
+                    })
+                    .ToList();
+
+                List<Vector3> addedNormals = currentMesh.normals
+                    .ToList()
+                    .GetRange(subMeshDescriptors[i].firstVertex, subMeshDescriptors[i].vertexCount)
+                    .Select(normal => RotateAndScaleVerticle(normal, currentTransform.rotation, Vector3.one, Vector3.zero))
+                    .ToList();
+
+                List<int> addedTriangleIndexes = currentMesh.triangles
+                    .ToList()
+                    .GetRange(subMeshDescriptors[i].indexStart, subMeshDescriptors[i].indexCount)
+                    .Select(index => index - subMeshDescriptors[i].firstVertex)
+                    .ToList();
+
+                int subMeshInfoIndex = subMeshesInfo
+                    .FindIndex(subMeshInfo => subMeshInfo.VerticesMaterial == meshMaterials[i]);
+                if (subMeshInfoIndex == -1)
+                {
+                    subMeshesInfo.Add(new SubMeshInfo
+                    {
+                        Vertices = addedVertices,
+                        UV = addedUV,
+                        Tangents = addedTangents,
+                        Normals = addedNormals,
+                        TriangleIndexes = addedTriangleIndexes,
+                        VerticesMaterial = meshMaterials[i]
+                    });
+                }
+                else
+                {
+                    subMeshesInfo[subMeshInfoIndex].TriangleIndexes
+                        .AddRange(addedTriangleIndexes
+                        .Select(index => index + subMeshesInfo[subMeshInfoIndex].Vertices.Count));
+                    subMeshesInfo[subMeshInfoIndex].Vertices.AddRange(addedVertices);
+                    subMeshesInfo[subMeshInfoIndex].UV.AddRange(addedUV);
+                    subMeshesInfo[subMeshInfoIndex].Tangents.AddRange(addedTangents);
+                    subMeshesInfo[subMeshInfoIndex].Normals.AddRange(addedNormals);
+                }
+            }
+        }
+
+        Material[] materials = new Material[subMeshesInfo.Count];
+
+        SubMeshDescriptor[] finalSubMeshDescriptors = new SubMeshDescriptor[subMeshesInfo.Count];
+
+        for (int i = 0; i < subMeshesInfo.Count; i++)
+        {
+            materials[i] = subMeshesInfo[i].VerticesMaterial;
+            int startVerticleIndex = vertices.Length;
+            int startTrianglesIndex = triangles.Length;
+
+            triangles = triangles
+                .Concat(subMeshesInfo[i].TriangleIndexes
+                .Select(index => index + vertices.Length))
+                .ToArray();
+            vertices = vertices
+                .Concat(subMeshesInfo[i].Vertices)
+                .ToArray();
+            uv = uv
+                .Concat(subMeshesInfo[i].UV)
+                .ToArray();
+            tangents = tangents
+                .Concat(subMeshesInfo[i].Tangents)
+                .ToArray();
+            normals = normals
+                .Concat(subMeshesInfo[i].Normals)
+                .ToArray();
+
+            finalSubMeshDescriptors[i] = new SubMeshDescriptor
+            {
+                firstVertex = startVerticleIndex,
+                indexStart = startTrianglesIndex,
+                vertexCount = subMeshesInfo[i].Vertices.Count,
+                indexCount = subMeshesInfo[i].TriangleIndexes.Count,
+            };
+        }
+
+        Mesh resultMesh = CreateMesh(vertices, triangles, uv, tangents, normals, finalSubMeshDescriptors);
+        GameObject house = CreateGameObject(resultMesh, materials);
+
+#if(UNITY_EDITOR)
+        if (_saveMesh) _meshSaver.SaveMesh(resultMesh, _savePath);
+#endif
+    }
+
+    private Vector3 RotateAndScaleVerticle(Vector3 verticle, Quaternion rotation, Vector3 scale, Vector3 pivot)
+    {
+        verticle = Vector3.Scale(verticle, scale);
+        Vector3 pos = rotation * (verticle - pivot) + pivot;
+        return pos;
+    }
+
+    private Vector3 Abs(Vector3 vector)
+    {
+        return new Vector3(Mathf.Abs(vector.x), Mathf.Abs(vector.y), Mathf.Abs(vector.z));
+    }
+
+    //private Vector3 GetGlobalScale(Transform transform)
+    //{
+    //    Vector3 scale = transform.rotation * transform.localScale;
+
+    //    if (transform.parent == null)
+    //        return Abs(scale);
+    //    else return Vector3.Scale(Abs(scale), GetGlobalScale(transform.parent));
+    //}
+    private Vector3 GetGlobalScale(Transform transform)
+    {
+        if (transform.parent == null)
+            return transform.localScale;
+        else return Vector3.Scale(transform.localScale, GetGlobalScale(transform.parent));
+    }
+
+    private Transform[] GetTargetTranforms(Transform[] transforms)
+    {
+        List<Transform> result = new List<Transform>();
+        for (int i = 0; i < transforms.Length; i++)
+        {
+            if (transforms[i].TryGetComponent(out MeshFilter meshFilter)) result.Add(transforms[i]);
+
+            Transform[] children = new Transform[transforms[i].childCount];
+            for (int t = 0; t < transforms[i].childCount; t++) children[t] = transforms[i].GetChild(t);
+            result.AddRange(GetTargetTranforms(children));
+        }
+
+        return result.ToArray();
+    }
+
+    private Mesh CreateMesh(Vector3[] vertices, int[] triangles, Vector2[] uv, Vector4[] tangents, Vector3[] normals, SubMeshDescriptor[] subMeshDescriptors)
+    {
+        Mesh resultMesh = new Mesh();
+
+        resultMesh.vertices = vertices;
+        resultMesh.triangles = triangles;
+        resultMesh.uv = uv;
+        resultMesh.tangents = tangents;
+        resultMesh.normals = normals;
+        resultMesh.name = $"{_objectName}Mesh";
+        resultMesh.subMeshCount = subMeshDescriptors.Length;
+        for (int i = 0; i < subMeshDescriptors.Length; i++) resultMesh.SetSubMesh(i, subMeshDescriptors[i]);
+
+        resultMesh.RecalculateBounds();
+
+        return resultMesh;
+    }
+
+    private GameObject CreateGameObject(Mesh mesh, Material[] materials)
+    {
+        GameObject house = new GameObject(_objectName);
+        house.AddComponent<MeshFilter>().sharedMesh = mesh;
+        house.AddComponent<MeshRenderer>().sharedMaterials = materials;
+
+        return house;
+    }
+
+    private struct SubMeshInfo
+    {
+        public List<Vector3> Vertices;
+        public List<Vector2> UV;
+        public List<Vector4> Tangents;
+        public List<Vector3> Normals;
+        public List<int> TriangleIndexes;
+        public Material VerticesMaterial;
+    }
+}
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4951b9b6f627cc34590ceb20c56d6751
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,34 @@
+#if(UNITY_EDITOR)
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+public class MeshSaver
+{
+    public void SaveMesh(Mesh mesh, string path)
+    {
+        if (!AssetDatabase.IsValidFolder(path)) CreateFolder(path);
+        AssetDatabase.CreateAsset(mesh, $"{path}/{mesh.name}{Random.Range(100000, 1000000)}.asset");
+    }
+
+    private void CreateFolder(string path)
+    {
+        string[] folders = path.Split('/');
+        for (int folderIndex = 0; !AssetDatabase.IsValidFolder(path); folderIndex++)
+            AssetDatabase.CreateFolder(GetPath(folders, folderIndex + 1), folders[folderIndex + 1]);
+    }
+
+    private string GetPath(string[] folders, int foldersCount)
+    {
+        string result = "";
+        for (int i = 0; i < foldersCount; i++)
+        {
+            result += folders[i];
+            if (i < foldersCount - 1) result += "/";
+        }
+
+        return result;
+    }
+}
+#endif
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 977e778b706fdf348af23db1a1a39840
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: