feat: Added support to LDtkTableOfContents ScriptableObject to get fields, and also can access entity definition data from a toc entry

Author: Cammin

Assets/LDtkUnity/Editor/CustomEditor/LDtkTableOfContentsEditor.cs

@@ -0,0 +1,11 @@
+using UnityEditor;
+
+namespace LDtkUnity.Editor
+{
+    // This class merely existing makes the inspector draw with no scroll rects
+    [CustomEditor(typeof(LDtkTableOfContents))]
+    internal sealed class LDtkTableOfContentsEditor : UnityEditor.Editor
+    {
+        
+    }
+}

Assets/LDtkUnity/Editor/CustomEditor/LDtkTableOfContentsEditor.cs.meta

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+
+namespace LDtkUnity.Editor
+{
+    /// <summary>
+    /// toc fields are only keyed by the entity's identifier and then the field's identifier. no uid.
+    /// So we should build up a dictionary by identifier for easy lookup
+    /// </summary>
+    internal sealed class LDtkTocFieldFactory
+    {
+        private LdtkJson _json;
+        private readonly LDtkJsonImporter _importer;
+        private readonly LDtkProjectImporter _project;
+        
+        private Dictionary<string, EntityFieldDefsByIdentifier> _entityIdentifierToFieldDefs;
+        private Dictionary<string, LDtkDefinitionObjectEntity> _entityIdentifierToEntityDefinition;
+
+        public class TocFieldFactoryOutput
+        {
+            public LDtkDefinitionObjectEntity Definition;
+            public List<LDtkField[]> Fields;
+        }
+            
+        
+        private class EntityFieldDefsByIdentifier : Dictionary<string, FieldDefinition>
+        {
+            public EntityFieldDefsByIdentifier(int capacity) : base(capacity) { }
+        }
+        
+        public LDtkTocFieldFactory(LdtkJson json, LDtkJsonImporter importer, LDtkProjectImporter project)
+        {
+            _json = json;
+            _importer = importer;
+            _project = project;
+        }
+
+        public void IndexEntitiesAndFieldsByIdentifiers()
+        {
+            //no preallocate because we aren't necessarily covering all entities
+            _entityIdentifierToFieldDefs = new Dictionary<string, EntityFieldDefsByIdentifier>();
+            _entityIdentifierToEntityDefinition = new Dictionary<string, LDtkDefinitionObjectEntity>();
+            
+            foreach (EntityDefinition entityDef in _json.Defs.Entities)
+            {
+                //skip caching any that don't export to toc
+                if (!entityDef.ExportToToc) continue;
+                
+                _entityIdentifierToEntityDefinition.Add(entityDef.Identifier, _importer.DefinitionObjects.GetObject<LDtkDefinitionObjectEntity>(entityDef.Uid));
+                
+                EntityFieldDefsByIdentifier fields = new EntityFieldDefsByIdentifier(entityDef.FieldDefs.Length);
+                foreach (FieldDefinition fieldDef in entityDef.FieldDefs)
+                {
+                    //skip caching fields that don't export to toc
+                    if (!fieldDef.ExportToToc) continue;
+                    
+                    fields.Add(fieldDef.Identifier, fieldDef);
+                }
+                _entityIdentifierToFieldDefs.Add(entityDef.Identifier, fields);
+            }
+        }
+        
+        /// <summary>
+        /// One Toc entry can have multiple instances. so a list for each eneityt, and the element is an array of fields that the entity would possess.
+        /// </summary>
+        /// <param name="entry"></param>
+        /// <returns></returns>
+        public TocFieldFactoryOutput GenerateFieldsFromTocEntry(LdtkTableOfContentEntry entry)
+        {
+            string entityIdentifier = entry.Identifier;
+
+            List<LDtkField[]> fieldsList = new List<LDtkField[]>();
+            
+            LdtkTocInstanceData[] instances = entry.UnityInstances();
+            foreach (LdtkTocInstanceData instance in instances)
+            {
+                LDtkField[] fields = GetFields(entityIdentifier, instance.Fields);
+                fieldsList.Add(fields);
+            }
+
+            TocFieldFactoryOutput output = new TocFieldFactoryOutput()
+            {
+                Definition = _entityIdentifierToEntityDefinition[entityIdentifier],
+                Fields = fieldsList
+            };
+
+            return output;
+        }
+
+        private LDtkField[] GetFields(string entityIdentifier, Dictionary<string,object> srcFields)
+        {
+            LDtkFieldFactory fieldFactory = new LDtkFieldFactory(_project, _importer);
+
+            LDtkField[] fields = new LDtkField[srcFields.Count];
+            
+            int i = 0;
+            foreach (var fieldIdentifier in srcFields.Keys)
+            {
+                FieldDefinition def = GetFieldDefByFieldIdentifier(entityIdentifier, fieldIdentifier);
+                fields[i] = fieldFactory.GetFieldFromInstance(def, srcFields[fieldIdentifier]);
+                i++;
+            }
+            
+            return fields;
+        }
+        
+        /// <summary>
+        /// The important part about this:
+        /// A Toc field is only identified by its name. use the entity's name and the field name to figure out the type of the field to get it's object and then parse it.
+        /// </summary>
+        private FieldDefinition GetFieldDefByFieldIdentifier(string entityIdentifier, string fieldIdentifier)
+        {
+            if (_entityIdentifierToFieldDefs.TryGetValue(entityIdentifier, out EntityFieldDefsByIdentifier fields))
+            {
+                if (fields.TryGetValue(fieldIdentifier, out FieldDefinition fieldDef))
+                {
+                    return fieldDef;
+                }
+
+                LDtkDebug.LogError($"The field identifier \"{fieldIdentifier}\" does not exist in the entity \"{entityIdentifier}\"");
+            }
+            else
+            {
+                LDtkDebug.LogWarning($"The entity identifier \"{entityIdentifier}\" does not exist in the table of contents");
+            }
+
+            return null;
+        }
+    }
+}

Assets/LDtkUnity/Editor/ParsedField/LDtkTocFieldFactory.cs

@@ -234,6 +234,10 @@ private void CreateJsonAsset()
             _jsonFile = ReadAssetText();
             ImportContext.AddObjectToAsset("jsonFile", _jsonFile, LDtkIconUtility.LoadListIcon());
         }
+        /// <summary>
+        /// Should process after all the definition scriptable objects are created so that they are accessible in this context
+        /// </summary>
+        /// <param name="json"></param>
         private void TryCreateTableOfContents(LdtkJson json)
         {
             if (json.Toc.IsNullOrEmpty())
@@ -243,7 +247,25 @@ private void TryCreateTableOfContents(LdtkJson json)
 
             Toc = ScriptableObject.CreateInstance<LDtkTableOfContents>();
             Toc.name += AssetName + "_Toc";
-            Toc.Initialize(json);
+
+            LDtkTocFieldFactory factory = new LDtkTocFieldFactory(json, this, this);
+            
+            LDtkProfiler.BeginSample("Toc_IndexEntitiesAndFieldsByIdentifiers");
+            factory.IndexEntitiesAndFieldsByIdentifiers();
+            LDtkProfiler.EndSample();
+
+            Toc.InitializeList(json);
+            
+            LDtkFieldParser.CacheRecentBuilder(null);
+            LDtkProfiler.BeginSample("Toc_GenerateAndAddEntries");
+            foreach (LdtkTableOfContentEntry tocEntry in json.Toc)
+            {
+                var output = factory.GenerateFieldsFromTocEntry(tocEntry);
+                Toc.AddEntry(tocEntry, output.Definition, output.Fields);
+            }
+            LDtkProfiler.EndSample();
+            
+            
             ImportContext.AddObjectToAsset("toc", Toc, LDtkIconUtility.LoadListIcon());
         }
 

Assets/LDtkUnity/Editor/ParsedField/LDtkTocFieldFactory.cs.meta

@@ -15,23 +15,25 @@ public sealed class LDtkTableOfContents : ScriptableObject
     {
         [SerializeField] internal List<LDtkTableOfContentsEntry> _entries;
 
-        internal void Initialize(LdtkJson json)
+        internal void InitializeList(LdtkJson json)
         {
             _entries = new List<LDtkTableOfContentsEntry>(json.Toc.Length);
-            foreach (LdtkTableOfContentEntry p in json.Toc)
-            {
-                _entries.Add(new LDtkTableOfContentsEntry(p));
-            }
+        }
+
+        internal void AddEntry(LdtkTableOfContentEntry entry, LDtkDefinitionObjectEntity def, List<LDtkField[]> fields)
+        {
+            LDtkTableOfContentsEntry newEntry = new LDtkTableOfContentsEntry(entry, def, fields);
+            _entries.Add(newEntry);
         }
 
         [PublicAPI, Obsolete("Use " + nameof(GetEntry) + " instead")]
         public LDtkReferenceToAnEntityInstance[] GetEntities(string identifier)
         {
-            return GetEntry(identifier)._entries.Select(p => p.EntityRef).ToArray();
+            return GetEntry(identifier).Entries.Select(p => p.EntityRef).ToArray();
         }
 
         /// <summary>
-        /// Gets all of the entity references in this table of contents of an entity type.
+        /// Gets all the entity references in this table of contents of an entity type.
         /// </summary>
         /// <param name="identifier">
         /// The identifier of the entity type to look for.
@@ -40,7 +42,7 @@ public LDtkTableOfContentsEntry GetEntry(string identifier)
         {
             foreach (LDtkTableOfContentsEntry entry in _entries)
             {
-                if (entry._identifier == identifier)
+                if (entry.Definition.Identifier == identifier)
                 {
                     return entry;
                 }
@@ -53,37 +55,57 @@ public LDtkTableOfContentsEntry GetEntry(string identifier)
     [Serializable]
     public sealed class LDtkTableOfContentsEntry
     {
-        public string _identifier;
-        public List<LDtkTableOfContentsEntryData> _entries;
-            
-        public LDtkTableOfContentsEntry(LdtkTableOfContentEntry entry)
+        [SerializeField] private LDtkDefinitionObjectEntity _def;
+        [SerializeField] private List<LDtkTableOfContentsEntryData> _entries;
+        
+        public LDtkDefinitionObjectEntity Definition => _def;
+        
+        /// <summary>
+        /// The list of entity instances in this table of contents entry.
+        /// </summary>
+        public List<LDtkTableOfContentsEntryData> Entries => _entries;
+        
+        internal LDtkTableOfContentsEntry(LdtkTableOfContentEntry entry, LDtkDefinitionObjectEntity def, List<LDtkField[]> fields)
         {
-            _identifier = entry.Identifier;
+            _def = def;
 
             LdtkTocInstanceData[] datas = entry.UnityInstances();
 
             _entries = new List<LDtkTableOfContentsEntryData>(datas.Length);
-            foreach (LdtkTocInstanceData p in datas)
+            for (int i = 0; i < datas.Length; i++)
             {
-                _entries.Add(new LDtkTableOfContentsEntryData(p));
+                _entries.Add(new LDtkTableOfContentsEntryData(datas[i], fields[i]));
             }
         }
     }
 
     [Serializable]
     public sealed class LDtkTableOfContentsEntryData
     {
-        public LDtkReferenceToAnEntityInstance EntityRef;
-        //public LDtkFields Field; //todo
-        public Vector2Int WorldPos;
-        public Vector2Int SizePx;
-
-        public LDtkTableOfContentsEntryData(LdtkTocInstanceData data)
+        [SerializeField] private LDtkReferenceToAnEntityInstance _entityRef;
+        [SerializeField] private Vector2Int _worldPos;
+        [SerializeField] private Vector2Int _sizePx;
+        [SerializeField] private LDtkField[] _fields;
+        
+        public LDtkReferenceToAnEntityInstance EntityRef => _entityRef;
+        public Vector2Int WorldPosition => _worldPos;
+        public Vector2Int Size => _sizePx;
+        public LDtkField[] Fields => _fields;
+        
+        /// <summary>
+        /// Finds a field by its identifier.
+        /// </summary>
+        public LDtkField GetField(string identifier)
+        {
+            return _fields.FirstOrDefault(p => p.Identifier == identifier);
+        }
+        
+        internal LDtkTableOfContentsEntryData(LdtkTocInstanceData data, LDtkField[] fields)
         {
-            EntityRef = new LDtkReferenceToAnEntityInstance(data.Iids);
-            //Field = data.Fields; todo
-            WorldPos = data.UnityWorld;
-            SizePx = data.UnitySizePx;
+            _entityRef = new LDtkReferenceToAnEntityInstance(data.Iids);
+            _fields = fields;
+            _worldPos = data.UnityWorld;
+            _sizePx = data.UnitySizePx;
         }
     }
 }