Initial release

Author: gleblebedev

.gitignore

@@ -0,0 +1 @@
+*.meta

LICENSE Urho3DExporter/LICENSELICENSE renamed to Urho3DExporter/LICENSE

@@ -0,0 +1,112 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Urho3DExporter
+{
+    public class AssetCollection : IEnumerable<AssetContext>
+    {
+        private readonly string _urhoDataPath;
+        private readonly List<AssetContext> _assets;
+
+        public AssetCollection(string urhoDataPath, IEnumerable<AssetContext> assets)
+        {
+            _urhoDataPath = urhoDataPath.Replace('/','\\');
+            if (!_urhoDataPath.EndsWith("\\"))
+                _urhoDataPath += '\\';
+            _assets = assets.ToList();
+            foreach (var assetContext in assets.Where(_=>_.Type == typeof(Material)))
+            {
+                AddMaterialPath(AssetDatabase.LoadAssetAtPath<Material>(assetContext.AssetPath),
+                    assetContext.UrhoAssetName);
+            }
+        }
+
+        public IEnumerator<AssetContext> GetEnumerator()
+        {
+            return _assets.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable) _assets).GetEnumerator();
+        }
+
+        public void AddMeshPath(Mesh mesh, string fileName)
+        {
+            if (fileName.StartsWith(_urhoDataPath, StringComparison.InvariantCultureIgnoreCase))
+                fileName = fileName.Substring(_urhoDataPath.Length).Replace('\\','/');
+            TryAdd(_meshPaths, mesh, mesh.name, fileName);
+        }
+
+        public bool TryAdd(Dictionary<string, string> values, UnityEngine.Object asset, string name, string fileName)
+        {
+            var path = AssetDatabase.GetAssetPath(asset);
+            var id = path + "#" + name;
+            if (values.ContainsKey(id))
+            {
+                //Debug.LogError("Duplicate asset " + id);
+                return false;
+            }
+            values.Add(id, fileName);
+            return true;
+        }
+
+        Dictionary<string, string> _meshPaths = new Dictionary<string, string>();
+
+        public bool TryGetMeshPath(Mesh sharedMesh, out string meshPath)
+        {
+            meshPath = null;
+            if (sharedMesh == null)
+                return false;
+            var path = AssetDatabase.GetAssetPath(sharedMesh);
+            var id = path + "#" + sharedMesh.name;
+            return _meshPaths.TryGetValue(id, out meshPath);
+        }
+
+        public void AddMaterialPath(Material material, string fileName)
+        {
+
+            if (fileName.StartsWith(_urhoDataPath, StringComparison.InvariantCultureIgnoreCase))
+                fileName = fileName.Substring(_urhoDataPath.Length).Replace('\\', '/');
+            TryAdd(_materialPaths, material, material.name, fileName);
+        }
+
+        Dictionary<string, string> _materialPaths = new Dictionary<string, string>();
+
+        public bool TryGetMaterialPath(Material sharedMaterial, out string materialPath)
+        {
+            materialPath = null;
+            if (sharedMaterial == null)
+                return false;
+            var path = AssetDatabase.GetAssetPath(sharedMaterial);
+            var id = path + "#" + sharedMaterial.name;
+            return _materialPaths.TryGetValue(id, out materialPath);
+        }
+
+
+
+        public void AddTexturePath(Texture material, string fileName)
+        {
+
+            if (fileName.StartsWith(_urhoDataPath, StringComparison.InvariantCultureIgnoreCase))
+                fileName = fileName.Substring(_urhoDataPath.Length).Replace('\\', '/');
+            TryAdd(_texturePaths, material, material.name, fileName);
+        }
+
+        Dictionary<string, string> _texturePaths = new Dictionary<string, string>();
+
+        public bool TryGetTexturePath(Texture sharedTexture, out string materialPath)
+        {
+            materialPath = null;
+            if (sharedTexture == null)
+                return false;
+            var path = AssetDatabase.GetAssetPath(sharedTexture);
+            var id = path + "#" + sharedTexture.name;
+            return _texturePaths.TryGetValue(id, out materialPath);
+        }
+    }
+}

Urho3DExporter/Scripts/Editor/AssetCollection.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace Urho3DExporter
+{
+    public class AssetContext
+    {
+        public string UrhoFileName { get; private set; }
+
+        public string UrhoAssetName { get; private set; }
+
+        public string FullPath { get; private set; }
+
+        public string RelPath { get; private set; }
+
+        public Type Type { get; private set; }
+
+        public string AssetPath { get; private set; }
+
+        public string Guid { get; private set; }
+
+        public string ContentFolder { get; private set; }
+        
+        public bool Is3DAsset { get; private set; }
+
+        private static readonly HashSet<string> _supported3DFormats = new HashSet<string>()
+        {
+            ".fbx",
+            ".obj",
+            ".dae",
+            ".3ds",
+            ".dxf",
+            ".max",
+            ".ma",
+            ".mb",
+            ".blend",
+        };
+
+        public static AssetContext Create(string guid, string urhoDataFolder)
+        {
+            var res = new AssetContext
+            {
+                Guid = guid
+            };
+            res.AssetPath = AssetDatabase.GUIDToAssetPath(guid);
+            if (!string.IsNullOrEmpty(res.AssetPath))
+            {
+                res.Type = AssetDatabase.GetMainAssetTypeAtPath(res.AssetPath);
+                res.RelPath = res.AssetPath;
+                if (res.RelPath.StartsWith("Assets/", StringComparison.InvariantCultureIgnoreCase))
+                    res.RelPath = res.RelPath.Substring("Assets/".Length);
+                res.FullPath = Path.Combine(Application.dataPath, res.RelPath);
+                res.FileExtension = System.IO.Path.GetExtension(res.AssetPath).ToLower();
+                res.UrhoAssetName = res.RelPath;
+                if (res.Type == typeof(Material))
+                    res.UrhoAssetName = RepaceExtension(res.UrhoAssetName, ".xml");
+                else if (res.Type == typeof(GameObject))
+                {
+                    res.UrhoAssetName = RepaceExtension(res.UrhoAssetName, ".xml");
+                    res.Is3DAsset = _supported3DFormats.Contains(res.FileExtension);
+                }
+                else if (res.Type == typeof(SceneAsset)) res.UrhoAssetName = RepaceExtension(res.UrhoAssetName, ".xml");
+                res.UrhoFileName = System.IO.Path.Combine(urhoDataFolder, res.UrhoAssetName);
+                if (res.Is3DAsset)
+                {
+                    res.ContentFolder = res.UrhoFileName.Substring(0, res.UrhoFileName.Length - ".xml".Length);
+                }
+            }
+
+            return res;
+        }
+
+        public string FileExtension { get; private set; }
+
+        private static string RepaceExtension(string resUrhoAssetName, string newExt)
+        {
+            var ext = System.IO.Path.GetExtension(resUrhoAssetName);
+            return resUrhoAssetName.Substring(0, resUrhoAssetName.Length - ext.Length) + newExt;
+        }
+    }
+}