com.warwlock.mtree 1.0.2

package/Runtime/TreeFunctions/BranchFunction.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class BranchFunction : TreeFunctionAsset
+    {
+        public float length = 7f;
+        public AnimationCurve lengthCurve = AnimationCurve.Linear(0, 1, 1, .8f);
+        public float resolution = 1f;
+        public int number = 30;
+        public float splitProba = .1f;
+        public float angle = .7f;
+        public AnimationCurve shape = AnimationCurve.EaseInOut(0, 1, 1, .1f);
+        public AnimationCurve splitProbaCurve = AnimationCurve.Linear(0, .5f, 1, 1f);
+        public float radius = .6f;
+        public float randomness = .25f;
+        public float upAttraction = .5f;
+        public float start = .2f;
+        public float gravityStrength = .1f;
+        public bool obstacleAvoidance = false;
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Branch";
+
+            if (parent != null && !(parent is TrunkFunction) && !preserveSettings)
+            {
+                length = 3;
+                start = .3f;
+                angle = .4f;
+                number = 120;
+                resolution = 1;
+                splitProba = .3f;
+                radius = .8f;
+                shape = AnimationCurve.Linear(0, 1, 1, .1f);
+                randomness = .4f;
+                gravityStrength = 1f;
+            }
+        }
+
+        public override void DrawProperties()
+        {
+#if UNITY_EDITOR
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+            Utils.BoundedIntProperty(obj.FindProperty("number"), new GUIContent("Number"), 0);
+
+            EditorGUILayout.BeginHorizontal();
+            Utils.BoundedFloatProperty(obj.FindProperty("length"), new GUIContent("Length"), 0.001f);
+            EditorGUILayout.PropertyField(obj.FindProperty("lengthCurve"), new GUIContent(""));
+            EditorGUILayout.EndHorizontal();
+
+            Utils.BoundedFloatProperty(obj.FindProperty("resolution"), new GUIContent("Resolution"), 0.01f);
+            EditorGUILayout.Slider(obj.FindProperty("randomness"), 0, 1, new GUIContent("Randomness"));
+            EditorGUILayout.Slider(obj.FindProperty("radius"), 0.001f, 1, new GUIContent("Radius"));
+            EditorGUILayout.PropertyField(obj.FindProperty("shape"), new GUIContent("Shape"));
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.Slider(obj.FindProperty("splitProba"), 0, 1, new GUIContent("Split proba"));
+            EditorGUILayout.PropertyField(obj.FindProperty("splitProbaCurve"), new GUIContent(""));
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Slider(obj.FindProperty("angle"), 0, 1, new GUIContent("Angle"));
+            EditorGUILayout.PropertyField(obj.FindProperty("upAttraction"), new GUIContent("Up attraction"));
+            EditorGUILayout.PropertyField(obj.FindProperty("gravityStrength"), new GUIContent("Gravity Strength"));
+            EditorGUILayout.Slider(obj.FindProperty("start"), 0, 1, new GUIContent("Start"));
+            EditorGUILayout.PropertyField(obj.FindProperty("obstacleAvoidance"), new GUIContent("React to scene colliders"));
+
+            obj.ApplyModifiedProperties();
+
+#endif
+        }
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+            int selection = parent == null ? 0 : parent.id;
+            tree.AddBranches(selection, length, lengthCurve, resolution, number, splitProba, splitProbaCurve, angle
+                            , randomness, shape, radius, upAttraction, id, start, gravityStrength, 0f, 0.001f, obstacleAvoidance);
+        }
+    }
+}

package/Runtime/TreeFunctions/BranchFunction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 33897084c7891e54eb6df4c02cb4118d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeFunctions/GrowFunction.cs

@@ -0,0 +1,81 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class GrowFunction : TreeFunctionAsset
+    {
+        public float length = 10f;
+        public AnimationCurve lengthCurve = AnimationCurve.Linear(0, 1, 1, .8f);
+        public float resolution = 1f;
+        public float splitProba = .1f;
+        public float splitAngle = .5f;
+        public int maxSplits = 2;
+        public AnimationCurve radius = AnimationCurve.EaseInOut(0, 1, 1, .1f);
+        public AnimationCurve splitProbaCurve = AnimationCurve.Linear(0, .5f, 1, 1f);
+        public float splitRadius = .8f;
+        public float randomness = .25f;
+        public float upAttraction = .5f;
+        public float gravityStrength = .1f;
+        public bool obstacleAvoidance = false;
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Grow";
+            if (!preserveSettings)
+            {
+                Keyframe[] keys = new Keyframe[2] { new Keyframe(0f, 1f, 0f, 0f), new Keyframe(1f, 0f, -.5f, -1f) };
+                radius = new AnimationCurve(keys);
+            }
+        }
+
+        public override void DrawProperties()
+        {
+#if UNITY_EDITOR
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+
+            EditorGUILayout.BeginHorizontal();
+            Utils.BoundedFloatProperty(obj.FindProperty("length"), new GUIContent("Length"), 0.001f);
+            EditorGUILayout.PropertyField(obj.FindProperty("lengthCurve"), new GUIContent(""));
+            EditorGUILayout.EndHorizontal();
+
+            Utils.BoundedFloatProperty(obj.FindProperty("resolution"), new GUIContent("Resolution"), 0.01f);
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.Slider(obj.FindProperty("splitProba"), 0, 1, new GUIContent("Split proba"));
+            EditorGUILayout.PropertyField(obj.FindProperty("splitProbaCurve"), new GUIContent(""));
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Slider(obj.FindProperty("splitAngle"), 0, 2, new GUIContent("Split Angle"));
+            EditorGUILayout.PropertyField(obj.FindProperty("radius"), new GUIContent("Shape"));
+            EditorGUILayout.Slider(obj.FindProperty("splitRadius"), .5f, .999f, new GUIContent("Split Radius"));
+            EditorGUILayout.IntSlider(obj.FindProperty("maxSplits"), 2, 4, new GUIContent("Max splits at a time"));
+            EditorGUILayout.Slider(obj.FindProperty("randomness"), 0, 1, new GUIContent("Randomness"));
+            EditorGUILayout.Slider(obj.FindProperty("upAttraction"), 0, 1, new GUIContent("Up attraction"));
+            EditorGUILayout.PropertyField(obj.FindProperty("gravityStrength"), new GUIContent("Gravity Strength"));
+            EditorGUILayout.PropertyField(obj.FindProperty("obstacleAvoidance"), new GUIContent("React to scene colliders"));
+
+            obj.ApplyModifiedProperties();
+
+#endif
+        }
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+            int selection = parent == null ? 0 : parent.id;
+                tree.Grow(length, lengthCurve, resolution, splitProba, splitProbaCurve, splitAngle, maxSplits, selection
+                        , id, randomness, radius, splitRadius, upAttraction, gravityStrength, 0f, 0.001f, obstacleAvoidance);
+        }
+    }
+}

package/Runtime/TreeFunctions/GrowFunction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0a7c716bf67b2c4ca1923c770d36116
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeFunctions/LeafFunction.cs

@@ -0,0 +1,111 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using System.Linq;
+namespace Mtree
+{
+    public class LeafFunction : TreeFunctionAsset
+    {
+        public int leafType = 4;
+        public static string[] leafTypesNames = { "cross", "diamond cross", "diamond", "long", "plane", "Procedural", "custom" };
+        public int number = 250;
+        public Mesh customLeafMesh;
+        public float maxRadius = .25f;
+        public float size = 2f;
+        public bool overrideNormals = true;
+        public float minWeight = .2f;
+        public float maxWeight = .5f;
+        public float length = 2f;
+        public AnimationCurve lengthCurve = AnimationCurve.Linear(0, 1, 1, 0.5f);
+        public int uLoops = 2;
+        public float resolution = 1f;
+        public float gravityStrength = 1f;
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Leaves";
+            customLeafMesh = null;
+        }
+
+#if UNITY_EDITOR
+        public override void DrawProperties()
+        {
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+
+            SerializedProperty leafTypeProp = obj.FindProperty("leafType");
+            leafTypeProp.intValue = EditorGUILayout.Popup(leafTypeProp.intValue, leafTypesNames);
+
+            if (leafTypeProp.intValue == 6)
+                EditorGUILayout.PropertyField(obj.FindProperty("customLeafMesh"), new GUIContent("Leaf mesh"));
+
+            Utils.BoundedIntProperty(obj.FindProperty("number"), new GUIContent("Number"), 0);
+            EditorGUILayout.PropertyField(obj.FindProperty("size"), new GUIContent("Size"));
+            EditorGUILayout.Slider(obj.FindProperty("maxRadius"), 0.001f, 1, "Max branch radius");
+
+            SerializedProperty minWeihtProp = obj.FindProperty("minWeight");
+            SerializedProperty maxWeihtProp = obj.FindProperty("maxWeight");
+            float minTmp = minWeihtProp.floatValue;
+            float maxTmp = maxWeihtProp.floatValue;
+            EditorGUILayout.MinMaxSlider("leafs weight", ref minTmp, ref maxTmp, -1, 1);
+            minWeihtProp.floatValue = minTmp;
+            maxWeihtProp.floatValue = maxTmp;
+
+            EditorGUILayout.PropertyField(obj.FindProperty("overrideNormals"), new GUIContent("Override normals"));
+            if (leafTypeProp.intValue == 5)
+            {
+                EditorGUILayout.PropertyField(obj.FindProperty("length"), new GUIContent("Length multiplier"));
+                EditorGUILayout.PropertyField(obj.FindProperty("lengthCurve"), new GUIContent("Length"));
+                Utils.BoundedFloatProperty(obj.FindProperty("resolution"), "resolution", 0.001f);
+                EditorGUILayout.IntSlider(obj.FindProperty("uLoops"), 2, 5, new GUIContent("Middle segments"));
+                EditorGUILayout.PropertyField(obj.FindProperty("gravityStrength"), new GUIContent("Gravity strength"));
+            }
+
+            obj.ApplyModifiedProperties();
+        }
+#endif
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+            int selection = parent == null ? 0 : parent.id;
+            bool procedural = leafType == 5;
+
+            Mesh[] leafMeshes = null;
+            switch (leafType)
+            {
+                case 0:
+                    leafMeshes = new Mesh[] { Resources.LoadAll<Mesh>("Mtree/branches")[0] };
+                    break;
+                case 1:
+                    leafMeshes = new Mesh[] { Resources.LoadAll<Mesh>("Mtree/branches")[1] };
+                    break;
+                case 2:
+                    leafMeshes = new Mesh[] { Resources.LoadAll<Mesh>("Mtree/branches")[2], Resources.LoadAll<Mesh>("Mtree/branches")[3] };
+                    break;
+                case 3:
+                    leafMeshes = new Mesh[] { Resources.LoadAll<Mesh>("Mtree/branches")[4], Resources.LoadAll<Mesh>("Mtree/branches")[5] };
+                    break;
+                case 4:
+                    leafMeshes = new Mesh[] { Resources.LoadAll<Mesh>("Mtree/branches")[6] };
+                    break;
+                case 5:
+                    leafMeshes = null;
+                    break;
+                case 6:
+                    leafMeshes = new Mesh[] { customLeafMesh };
+                    break;
+            }
+            
+            tree.AddLeafs(maxRadius, number, leafMeshes, size, overrideNormals, minWeight, maxWeight, selection, 70, procedural, length, resolution, uLoops, gravityStrength);
+        }
+    }
+}

package/Runtime/TreeFunctions/LeafFunction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 85d8cd2303af54543a4524493d539ae8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeFunctions/RootsFunction.cs

@@ -0,0 +1,77 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class RootsFunction : TreeFunctionAsset
+    {
+        public float length = 1.5f;
+        public float resolution = 3f;
+        public int number = 8;
+        public float splitProba = .4f;
+        public float angle = .3f;
+        public AnimationCurve shape = AnimationCurve.EaseInOut(0, 1, 1, .5f);
+        public AnimationCurve splitProbaCurve = AnimationCurve.Linear(0, .5f, 1, 1f);
+        public float radius = .6f;
+        public float randomness = .25f;
+        public float start = .1f;
+        public float end = .3f;
+        public float groundHeight = 0f;
+        public float attractionStrength = 1f;
+
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Roots";
+        }
+
+        public override void DrawProperties()
+        {
+#if UNITY_EDITOR
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+            Utils.BoundedIntProperty(obj.FindProperty("number"), new GUIContent("Number"), 0);
+
+            EditorGUILayout.BeginHorizontal();
+            Utils.BoundedFloatProperty(obj.FindProperty("length"), new GUIContent("Length"), 0.001f);
+            EditorGUILayout.EndHorizontal();
+
+            Utils.BoundedFloatProperty(obj.FindProperty("resolution"), new GUIContent("Resolution"), 0.01f);
+            EditorGUILayout.Slider(obj.FindProperty("randomness"), 0, 1, new GUIContent("Randomness"));
+            EditorGUILayout.Slider(obj.FindProperty("radius"), 0.001f, 1, new GUIContent("Radius"));
+            EditorGUILayout.PropertyField(obj.FindProperty("shape"), new GUIContent("Shape"));
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.Slider(obj.FindProperty("splitProba"), 0, 1, new GUIContent("Split proba"));
+            EditorGUILayout.PropertyField(obj.FindProperty("splitProbaCurve"), new GUIContent(""));
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Slider(obj.FindProperty("angle"), 0.1f, .95f, new GUIContent("Angle"));
+            Utils.BoundedFloatProperty(obj.FindProperty("start"), new GUIContent("Start height"), 0, end);
+            Utils.BoundedFloatProperty(obj.FindProperty("end"), new GUIContent("End height"), start);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("groundHeight"), new GUIContent("Ground height"));
+            Utils.BoundedFloatProperty(obj.FindProperty("attractionStrength"), new GUIContent("attraction strength"), 0f);
+
+            obj.ApplyModifiedProperties();
+
+#endif
+        }
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+            int selection = parent == null ? 0 : parent.id;
+            tree.AddRoots(selection, this);
+        }
+    }
+}

package/Runtime/TreeFunctions/RootsFunction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c81997976e05f6e45819b5dda33c654d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeFunctions/SplitFunction.cs

@@ -0,0 +1,50 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Mtree
+{
+    public class SplitFunction : TreeFunctionAsset
+    {
+        public int number = 25;
+        public float splitAngle = .5f;
+        public float splitRadius = .6f;
+        public float start = .2f;
+        public float spread = 1;
+
+        public override void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            base.Init(parent);
+            name = "Split";
+        }
+
+        public override void DrawProperties()
+        {
+#if UNITY_EDITOR
+
+            SerializedObject obj = new SerializedObject(this);
+
+            EditorGUILayout.PropertyField(obj.FindProperty("seed"), new GUIContent("Seed"));
+            Utils.BoundedIntProperty(obj.FindProperty("number"), new GUIContent("Number"), 0);
+            EditorGUILayout.Slider(obj.FindProperty("splitAngle"), 0, 2, new GUIContent("Split angle"));
+            EditorGUILayout.Slider(obj.FindProperty("splitRadius"), 0.001f, 1f, new GUIContent("Split Radius"));
+            EditorGUILayout.Slider(obj.FindProperty("start"), 0, 1, new GUIContent("Start"));
+            EditorGUILayout.Slider(obj.FindProperty("spread"), 0, 1, new GUIContent("Height spread"));
+
+            obj.ApplyModifiedProperties();
+#endif
+        }
+
+        public override void Execute(MTree tree)
+        {
+            base.Execute(tree);
+
+            Random.InitState(seed);
+            int selection = parent == null ? 0 : parent.id;
+            tree.Split(selection, number, splitAngle, id, splitRadius, start, spread, 0f);
+        }
+    }
+}

package/Runtime/TreeFunctions/SplitFunction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9305034f8c13a7747ac8c4719c0f237d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/TreeFunctions/TreeFunctionAsset.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Mtree
+{
+    public class TreeFunctionAsset : ScriptableObject
+    {
+        public int seed;
+
+        public static int positionOffset = 30; // offset in x position from parent
+        public static int height = 37;
+        public static int width = 200;
+        public static int margin = -3;
+        public static int deleteButtonSize = 18;
+
+        public static GUIStyle nodeStyle;
+        public static GUIStyle selectedNodeStyle;
+        public static GUIStyle deleteButtonStyle;
+
+        public int id;
+
+        public TreeFunctionAsset parent;
+        public List<TreeFunctionAsset> chiildren;
+        public bool enabled = true;
+        public bool showDeleteButton = true;
+
+        public Rect rect;
+        public Rect deleteRect;
+
+        public virtual void Init(TreeFunctionAsset parent, bool preserveSettings = false)
+        {
+            this.parent = parent;
+            if (parent != null)
+                parent.chiildren.Add(this);
+            chiildren = new List<TreeFunctionAsset>();
+            id = System.Guid.NewGuid().GetHashCode();
+            seed = Random.Range(0, 10000);
+        }
+
+        public virtual void Execute(MTree tree)
+        {
+            if (!enabled || (parent != null && !parent.enabled))
+                return;
+        }
+        
+        public void DrawFunction(bool isSelected = false, bool deleteButton = true)
+        {
+        #if UNITY_EDITOR
+            showDeleteButton = deleteButton;
+            GUIStyle style = isSelected ? selectedNodeStyle : nodeStyle;
+            if (style == null)
+                UpdateStyle();
+            GUI.Box(rect, name, style);
+
+            if (deleteButton)
+                GUI.Button(deleteRect, "", deleteButtonStyle);
+
+            if (parent != null)
+            {
+                Vector2 start_pos = parent.rect.position + new Vector2(6, height * 6 / 7);
+                Vector2 end_pos = rect.position + new Vector2(6, height / 2);
+                UnityEditor.Handles.DrawBezier(start_pos, end_pos, start_pos + Vector2.up * 15, end_pos + Vector2.left * 15, Color.white, null, 4f);
+            }
+        #endif
+        }
+
+        public void UpdateRectRec(ref int heightIndex, int marginIndex)
+        {
+            float x = marginIndex * positionOffset;
+            float y = heightIndex * (height + margin);
+            rect.Set(x, y, width, height);
+            if (showDeleteButton)
+                deleteRect.Set(x + width - 12 - deleteButtonSize, y + (height - deleteButtonSize) / 2, deleteButtonSize, deleteButtonSize);
+            else
+                deleteRect.Set(0, 0, 0, 0);
+            foreach (TreeFunctionAsset child in chiildren)
+            {
+                heightIndex++;
+                child.UpdateRectRec(ref heightIndex, marginIndex + 1);
+            }
+        }
+
+        public virtual void DrawProperties() {}
+
+        private static void UpdateStyle()
+        {
+        #if UNITY_EDITOR
+            nodeStyle = new GUIStyle();
+            nodeStyle.normal.background = Resources.Load("Mtree/Sprites/TreeFunctionSprite") as Texture2D;
+            nodeStyle.border = new RectOffset(20, 10, 10, 10);
+            nodeStyle.alignment = TextAnchor.MiddleCenter;
+            nodeStyle.normal.textColor = Color.white;
+            nodeStyle.fontStyle = FontStyle.Bold;
+
+            selectedNodeStyle = new GUIStyle(nodeStyle);
+            selectedNodeStyle.normal.background = Resources.Load("Mtree/Sprites/TreeFunctionSpriteSelected") as Texture2D;
+
+            deleteButtonStyle = new GUIStyle();
+            deleteButtonStyle.normal.background = Resources.Load("Mtree/Sprites/DeleteCrossSprite") as Texture2D;
+        #endif
+        }
+
+    }
+}

package/Runtime/TreeFunctions/TreeFunctionAsset.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d5eea620d5ae5d5419c8132b29ae6ae5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: