なつねこメモ

/*-------------------------------------------------------------------------------------------
 * Copyright (c) Natsuneko. All rights reserved.
 * Licensed under the MIT License. See LICENSE in the project root for license information.
 *------------------------------------------------------------------------------------------*/
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
 
using UnityEditor;
 
using UnityEngine;
using UnityEngine.UI;
 
using Object = UnityEngine.Object;
 
namespace Mochizuki.Camesh
{
    internal class CanvasToMesh : EditorWindow
    {
        [SerializeField]
        private Canvas[] canvases;
 
        [DirectoryField]
        [SerializeField]
        private DefaultAsset destTo;
 
        private List<Image> _images;
 
        private void OnGUI()
        {
            destTo = ObjectPicker("Destination To", destTo);
 
            EditorGUI.BeginChangeCheck();
 
            PropertyField(this, nameof(canvases));
 
            if (EditorGUI.EndChangeCheck())
                _images = (canvases ?? Array.Empty<Canvas>()).Where(w => w != null)
                                                             .Select(w => w.GetComponentInChildren<Image>())
                                                             .Where(w => w != null)
                                                             .ToList();
 
            if (GUILayout.Button("Generate Meshes for Canvas Images"))
                GenerateMeshesFromCanvasImages(_images, destTo);
        }
 
        private static void GenerateMeshesFromCanvasImages(List<Image> images, DefaultAsset destTo)
        {
            var dest = AssetDatabase.GetAssetPath(destTo);
            foreach (var (image, i) in images.Select((w, i) => (w, i)))
                GenerateMeshFromCanvasImage(image, Path.Combine(dest, $"{i}.asset"));
 
            AssetDatabase.Refresh();
        }
 
        private static void GenerateMeshFromCanvasImage(Image image, string dest)
        {
            // generate quad
            var canvas = image.GetComponent<RectTransform>();
            var rect = canvas.rect;
 
            var height = rect.height;
            var width = rect.width;
 
            var a = new Vector3(-1f * width / 2f, height / 2f);
            var b = new Vector3(width / 2f, height / 2f);
            var c = new Vector3(-1f * width / 2, -1f * height / 2f);
            var d = new Vector3(width / 2f, -1 * height / 2f);
            var tris = new[] { 0, 1, 2, 1, 3, 2 };
            var mesh = new Mesh { vertices = new[] { a, b, c, d }, triangles = tris };
 
            var w = 1 / 18f;
 
            var uvs = new[] { new Vector2(0, 1), new Vector2(1, 1), new Vector2(0, 0), new Vector2(1, 0) };
            mesh.SetUVs(0, uvs.ToList());
            mesh.RecalculateNormals();
 
            AssetDatabase.CreateAsset(mesh, dest);
        }
 
        [MenuItem("Mochizuki/Camesh/Editor")]
        public static void ShowWindow()
        {
            var window = GetWindow<CanvasToMesh>();
            window.titleContent = new GUIContent("Canvas Images to Mesh Converter");
 
            window.Show();
        }
 
        private static T ObjectPicker<T>(string label, T obj) where T : Object
        {
            return EditorGUILayout.ObjectField(new GUIContent(label), obj, typeof(T), true) as T;
        }
 
        private static void PropertyField(EditorWindow obj, string name)
        {
            var so = new SerializedObject(obj);
            so.Update();
 
            EditorGUILayout.PropertyField(so.FindProperty(name), true);
 
            so.ApplyModifiedProperties();
        }
    }
}