Updated to work after merge with trunk

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/AbstractGraphEditWindow.cs

 
 		public static bool allowAlwaysRepaint = true;
 
-        private bool shouldRepaint 
+        private bool shouldRepaint
         {
             get
             {
 
         void OnEnable()
         {
-            var source = CreateDataSource();
-			source.Initialize(inMemoryAsset, this);
-
-            m_GraphEditorDrawer = new GraphEditorDrawer(CreateGraphView(), source);
+            m_GraphEditorDrawer = new GraphEditorDrawer(CreateGraphView());
+            var source = CreateDataSource();
+            source.Initialize(inMemoryAsset, this);
+            m_GraphEditorDrawer.presenter = source;
         }
 
         void OnDisable()
         {
             if (shouldRepaint)
                 Repaint();
-        }
-
-        private bool focused { get; set; }
-        private void Focus(TimerState timerState)
-        {
-            m_GraphEditorDrawer.graphView.FrameAll();
-            focused = true;
         }
 
 		public void PingAsset()
                 {
                     return;
                 }
-                
+
                 var masterNode = ((MaterialGraphAsset)inMemoryAsset).materialGraph.masterNode;
                 if (masterNode == null)
                     return;
-                
+
                 var shaderImporter = AssetImporter.GetAtPath(path) as ShaderImporter;
                 if (shaderImporter == null)
                     return;
 			allowAlwaysRepaint = !allowAlwaysRepaint;
 		}
 
-		public void ChangeSelction(Object newSelection, bool refocus = true)
+		public void ChangeSelction(Object newSelection)
 		{
 			if (!EditorUtility.IsPersistent (newSelection))
 				return;
 			var source = CreateDataSource ();
 			source.Initialize (inMemoryAsset, this) ;
 			m_GraphEditorDrawer.presenter = source;
-			//m_GraphView.StretchToParentSize();
-			Repaint ();
-			if (refocus) 
-			{
-				focused = false;
-				m_GraphEditorDrawer.graphView.Schedule (Focus).StartingIn (1).Until (() => focused);
-			}
-		}
+            Repaint();
+        }
 
 		public void OnBeforeSerialize()
 		{

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Drawer/GraphEditorDrawer.cs

 using RMGUI.GraphView;
+using UnityEngine.Experimental.UIElements;
 
 namespace UnityEditor.Graphing.Drawing
 {
         private TitleBarDrawer m_TitleBarDrawer;
 
         // TODO: Create graphView from here rather than have it passed in through constructor
-        public GraphEditorDrawer(GraphView graphView, AbstractGraphPresenter presenter)
+        public GraphEditorDrawer(GraphView graphView)
+            AddStyleSheetPath("Styles/GraphEditor");
+
-            m_TitleBarDrawer = new TitleBarDrawer(presenter.titleBar);
+            m_TitleBarDrawer = new TitleBarDrawer();
-
-            this.presenter = presenter;
-
-            AddStyleSheetPath("Styles/GraphEditor");
         }
 
         public override void OnDataChanged()

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Drawer/NodeDrawer.cs

 using UnityEditor.Graphing.Util;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
+using UnityEngine.Experimental.UIElements.StyleEnums;
 
 namespace UnityEditor.Graphing.Drawing
 {
             m_ControlsContainer = new VisualContainer
             {
                 name = "controls",
-                pickingMode = PickingMode.Ignore,
+                //pickingMode = PickingMode.Ignore,
             };
 
             leftContainer.AddChild(m_ControlsContainer);
         private void AddControls(GraphNodePresenter nodeData)
         {
             var controlPresenters = nodeData.elements.OfType<GraphControlPresenter>().ToList();
+
+            m_ControlsContainer.ClearChildren();
+            m_CurrentControlPresenter.Clear();
-            {
-                m_ControlsContainer.ClearChildren();
-                m_CurrentControlPresenter.Clear();
-            }
-            if (controlPresenters.ItemsReferenceEquals(m_CurrentControlPresenter))
+            foreach (var controlData in controlPresenters)
-                for (int i = 0; i < controlPresenters.Count; i++)
-                {
-                    var controlData = controlPresenters[i];
-                    var imContainer = m_ControlsContainer.GetChildAt(i) as IMGUIContainer;
-                    imContainer.OnGuiHandler = controlData.OnGUIHandler;
-                    imContainer.height = controlData.GetHeight();
-                }
+                m_ControlsContainer.AddChild(CreateControl(controlData));
+                m_CurrentControlPresenter.Add(controlData);
-            else
-            {
-                m_ControlsContainer.ClearChildren();
-                m_CurrentControlPresenter.Clear();
+        }
-                foreach (var controlData in controlPresenters)
-                {
-                    var imContainer = new IMGUIContainer(controlData.OnGUIHandler)
-                    {
-                        name = "element",
-                        pickingMode = PickingMode.Position,
-                        height = controlData.GetHeight()
-                    };
-                    m_ControlsContainer.AddChild(imContainer);
-                    m_CurrentControlPresenter.Add(controlData);
-                }
-            }
+        IMGUIContainer CreateControl(GraphControlPresenter controlPresenter)
+        {
+            return new IMGUIContainer(controlPresenter.OnGUIHandler)
+            {
+                name = "element",
+                executionContext = controlPresenter.GetInstanceID(),
+            };
         }
 
         public override void OnDataChanged()
 
             if (nodeData == null)
             {
-                ClearChildren();
+                m_ControlsContainer.ClearChildren();
+                m_CurrentControlPresenter.Clear();
                 return;
             }
 

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Drawer/TitleBarDrawer.cs

             }
         }
 
-        public TitleBarDrawer(TitleBarPresenter dataProvider)
+        public TitleBarDrawer()
         {
             name = "TitleBar";
 
             };
             AddChild(m_RightContainer);
 
-            foreach (var leftItemData in dataProvider.leftItems)
-                m_LeftContainer.AddChild(new TitleBarButtonDrawer(leftItemData));
-
-            foreach (var rightItemData in dataProvider.rightItems)
-                m_RightContainer.AddChild(new TitleBarButtonDrawer(rightItemData));
-
-            this.dataProvider = dataProvider;
             AddStyleSheetPath("Styles/TitleBar");
         }
 
 
         void UpdateContainer(VisualContainer container, IEnumerable<TitleBarButtonPresenter> itemDatas)
         {
-            // The number of items can't change for now.
-            foreach (var pair in itemDatas.Zip(container.OfType<TitleBarButtonDrawer>()))
-            {
-                var itemData = pair.Item1;
-                var item = pair.Item2;
-                item.dataProvider = itemData;
-            }
+            container.ClearChildren();
+            foreach (var itemPresenter in itemDatas)
+                container.AddChild(new TitleBarButtonDrawer(itemPresenter));
         }
 
         protected override object toWatch

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Manipulators/ClickGlobalSelector.cs

     {
         public ClickGlobalSelector()
         {
-            phaseInterest = PropagationPhase.Capture;
-        public override EventPropagation HandleEvent(Event evt, VisualElement finalTarget)
+        public void HandleEvent(MouseEventBase evt)
         {
             var graphView = target as SerializableGraphView;
 			if (graphView == null)
+        }
-            return EventPropagation.Continue;
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback<MouseDownEvent>(HandleEvent, Capture.Capture);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback<MouseDownEvent>(HandleEvent, Capture.Capture);
         }
     }
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Manipulators/Clicker.cs

+using System;
 using UnityEngine;
 using UnityEngine.Experimental.UIElements;
 using MouseManipulator = UnityEngine.Experimental.UIElements.MouseManipulator;
 			activators.Add(new ManipulatorActivationFilter {button = MouseButton.LeftMouse});
 		}
 
-		public override EventPropagation HandleEvent(Event evt, VisualElement finalTarget)
-        {
-            switch (evt.type)
-            {
-                case EventType.MouseDown:
-                    if (CanStartManipulation(evt))
-                    {
-                        this.TakeCapture();
-                        initialTarget = finalTarget;
-                        UpdateState(evt);
-                    }
-                    break;
-
-                case EventType.mouseDrag:
-                    UpdateState(evt);
-                    break;
-
-                case EventType.MouseUp:
-                    if (CanStopManipulation(evt))
-                    {
-                        this.ReleaseCapture();
-                        // withinInitialTarget = initialTarget != null && initialTarget.ContainsPoint(evt.mousePosition);
-                        if (initialTarget != null && state == ClickerState.Active && onClick != null)
-                            onClick();
-                        initialTarget = null;
-                        UpdateState(evt);
-                    }
-                    break;
-            }
-            return this.HasCapture() ? EventPropagation.Stop : EventPropagation.Continue;
-        }
-
-        void UpdateState(Event evt)
+        void UpdateState(MouseEventBase evt)
         {
             ClickerState newState;
             if (initialTarget != null && initialTarget.ContainsPoint(evt.mousePosition))
             if (onStateChange != null && state != newState)
                 onStateChange(newState);
             state = newState;
+        }
+
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback<MouseUpEvent>(OnMouseUp, Capture.Capture);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback<MouseUpEvent>(OnMouseUp, Capture.Capture);
+        }
+
+        void OnMouseUp(MouseUpEvent evt)
+        {
+            onClick();
         }
     }
 }

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Drawing/Manipulators/Commandable.cs

             m_Dictionary = new Dictionary<string, CommandHandler>();
         }
 
-        public override EventPropagation HandleEvent(Event evt, VisualElement finalTarget)
+        public void HandleEvent(EventBase evt)
-            var isValidation = evt.type == EventType.ValidateCommand;
-            var isExecution = evt.type == EventType.ExecuteCommand;
+            var isValidation = evt.imguiEvent.type == EventType.ValidateCommand;
+            var isExecution = evt.imguiEvent.type == EventType.ExecuteCommand;
-                Debug.Log(evt.commandName);
+                Debug.Log(evt.imguiEvent.commandName);
-            if ((!isValidation && !isExecution) || !m_Dictionary.TryGetValue(evt.commandName, out handler))
-                return EventPropagation.Continue;
+            if ((!isValidation && !isExecution) || !m_Dictionary.TryGetValue(evt.imguiEvent.commandName, out handler))
+            {
+                return;
+            }
-                return EventPropagation.Stop;
+            {
+                evt.StopPropagation();
+                return;
+            }
-                return EventPropagation.Continue;
+            {
+                return;
+            }
-            return EventPropagation.Stop;
+            evt.StopPropagation();
         }
 
         public void Add(string commandName, CommandValidator validator, CommandExecutor executor)
         public IEnumerator<KeyValuePair<string, CommandHandler>> GetEnumerator()
         {
             return m_Dictionary.GetEnumerator();
+        }
+
+        protected override void RegisterCallbacksOnTarget()
+        {
+            target.RegisterCallback<IMGUIEvent>(HandleEvent);
+        }
+
+        protected override void UnregisterCallbacksFromTarget()
+        {
+            target.UnregisterCallback<IMGUIEvent>(HandleEvent);
         }
     }
 

MaterialGraphProject/Assets/GraphFramework/SerializableGraph/Editor/Resources/Styles/GraphEditor.uss

 
 GraphEditorDrawer #GraphView {
     flex: 1;
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Drawer/MaterialNodeDrawer.cs

 {
     public class MaterialNodeDrawer : NodeDrawer
     {
-        VisualContainer m_PreviewContainer;
-        private List<NodePreviewPresenter> m_currentPreviewData;
+        Image m_PreviewImage;
+        NodePreviewPresenter m_currentPreviewData;
         bool m_IsScheduled;
 
         public MaterialNodeDrawer()
 
         private void CreateContainers()
         {
-            m_PreviewContainer = new VisualContainer
+            m_PreviewImage = new Image
+                image = Texture2D.whiteTexture
-            leftContainer.AddChild(m_PreviewContainer);
-
-            m_currentPreviewData = new List<NodePreviewPresenter>();
+            m_PreviewImage.AddToClassList("inactive");
+            leftContainer.AddChild(m_PreviewImage);
         }
 
         private void SchedulePolling()
             if (childrenNodes.OfType<IRequiresTime>().Any())
             {
                 data.OnModified(ModificationScope.Node);
+                var texture = m_currentPreviewData != null ? m_currentPreviewData.Render(new Vector2(256, 256)) : null;
+                m_PreviewImage.image = texture ?? Texture2D.whiteTexture;
+                m_PreviewImage.RemoveFromClassList("inactive");
             }
             ListPool<INode>.Release(childrenNodes);
         }
             if (!nodeData.elements.OfType<NodePreviewPresenter>().Any())
                 return;
 
-            var previews = nodeData.elements.OfType<NodePreviewPresenter>().ToList();
+            var preview = nodeData.elements.OfType<NodePreviewPresenter>().FirstOrDefault();
+            var texture = preview != null ? preview.Render(new Vector2(256, 256)) : null;
-            if (!previews.ItemsReferenceEquals(m_currentPreviewData))
+            if (texture == null)
+            {
+                m_PreviewImage.AddToClassList("inactive");
+                m_PreviewImage.image = Texture2D.whiteTexture;
+            }
+            else
-                m_PreviewContainer.ClearChildren();
-                m_currentPreviewData = previews;
+                m_PreviewImage.RemoveFromClassList("inactive");
+                m_PreviewImage.image = preview.Render(new Vector2(256, 256));
+            }
-                foreach (var preview in previews)
-                {
-                    var thePreview = new NodePreviewDrawer
-                    {
-                        data = preview,
-                        name = "image"
-                    };
-                    m_PreviewContainer.AddChild(thePreview);
-                }
-            }
+            m_currentPreviewData = preview;
         }
 
         public override void OnDataChanged()
             var nodeData = GetPresenter<MaterialNodePresenter>();
             if (nodeData == null)
             {
-                m_PreviewContainer.ClearChildren();
-                m_currentPreviewData.Clear();
+                m_PreviewImage.AddToClassList("inactive");
+                m_currentPreviewData = null;
                 return;
             }
 
             {
-                //m_PreviewContainer.paintFlags &= ~PaintFlags.Invisible;
-                m_PreviewContainer.RemoveFromClassList("hidden");
+                //m_PreviewImage.paintFlags &= ~PaintFlags.Invisible;
+                m_PreviewImage.RemoveFromClassList("hidden");
-                //m_PreviewContainer.paintFlags |= PaintFlags.Invisible;
-                m_PreviewContainer.AddToClassList("hidden");
+                //m_PreviewImage.paintFlags |= PaintFlags.Invisible;
+                m_PreviewImage.AddToClassList("hidden");
             }
         }
     }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Drawer/NodePreviewDrawer.cs

     {
         public NodePreviewPresenter data;
 
-        public override void DoRepaint(IStylePainter painter)
+        public override void DoRepaint()
+            Debug.Log("DoRepaint");
-
-            painter.DrawTexture(position, image, new Color(1, 1, 1, 1), scaleMode);
-            //base.DoRepaint(args);
+            base.DoRepaint();
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/MaterialGraphView.cs

 using UnityEngine.MaterialGraph;
 using UnityEngine.Experimental.UIElements;
 using Edge = RMGUI.GraphView.Edge;
+using MouseButton = RMGUI.GraphView.MouseButton;
 using Object = UnityEngine.Object;
 
 namespace UnityEditor.MaterialGraph.Drawing
         public MaterialGraphView()
         {
-            AddManipulator(new ContextualMenu(DoContextMenu));
+            RegisterCallback<MouseUpEvent>(DoContextMenu);
 
             typeFactory[typeof(MaterialNodePresenter)] = typeof(MaterialNodeDrawer);
             typeFactory[typeof(GraphAnchorPresenter)] = typeof(NodeAnchor);
             return true;
         }
 
-        protected EventPropagation DoContextMenu(Event evt, Object customData)
+        protected void DoContextMenu(MouseUpEvent evt)
-            var gm = new GenericMenu();
-            foreach (Type type in Assembly.GetAssembly(typeof(AbstractMaterialNode)).GetTypes())
+            if (evt.button == (int)MouseButton.RightMouse)
-                if (type.IsClass && !type.IsAbstract && (type.IsSubclassOf(typeof(AbstractMaterialNode))))
+                var gm = new GenericMenu();
+                foreach (Type type in Assembly.GetAssembly(typeof(AbstractMaterialNode)).GetTypes())
-                    var attrs = type.GetCustomAttributes(typeof(TitleAttribute), false) as TitleAttribute[];
-                    if (attrs != null && attrs.Length > 0 && CanAddToNodeMenu(type))
+                    if (type.IsClass && !type.IsAbstract && (type.IsSubclassOf(typeof(AbstractMaterialNode))))
-                        gm.AddItem(new GUIContent(attrs[0].m_Title), false, AddNode, new AddNodeCreationObject(type, evt.mousePosition));
+                        var attrs = type.GetCustomAttributes(typeof(TitleAttribute), false) as TitleAttribute[];
+                        if (attrs != null && attrs.Length > 0 && CanAddToNodeMenu(type))
+                        {
+                            gm.AddItem(new GUIContent(attrs[0].m_Title), false, AddNode, new AddNodeCreationObject(type, evt.mousePosition));
+                        }
+
+                //gm.AddSeparator("");
+                // gm.AddItem(new GUIContent("Convert To/SubGraph"), true, ConvertSelectionToSubGraph);
+                gm.ShowAsContext();
-
-            //gm.AddSeparator("");
-            // gm.AddItem(new GUIContent("Convert To/SubGraph"), true, ConvertSelectionToSubGraph);
-            gm.ShowAsContext();
-            return EventPropagation.Stop;
+            evt.StopPropagation();
         }
 
         private class AddNodeCreationObject : object

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/SurfaceMasterPresenter.cs

 using System.Collections.Generic;
 using RMGUI.GraphView;
 using UnityEditor.Graphing.Drawing;
+using UnityEngine;
 using UnityEngine.MaterialGraph;
 
 namespace UnityEditor.MaterialGraph.Drawing

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Styles/MaterialGraph.uss

 .MaterialNode #preview {
-	flex-direction: column;
-	background-color: #444;
+	height: 200;
+	width: 200;
-.MaterialNode #preview #image {
-	height: 200;
-	width: 200;
+.MaterialNode #preview.inactive {
+	background-color: #FF0000;
 }
 
 GridBackground {
 	spacing:75.0;
 	thick-lines:10;
-}
+}

MaterialGraphProject/Assets/_MingWai/GeneratedTextureDemo/0-UnityLogo-Texture.asset.meta

 fileFormatVersion: 2
-guid: 28805740b89754d4f87ecf03fa9a100d
+guid: f5a9b1ce6937e6348af4e169bd4b0f3d
 timeCreated: 1495750594
 licenseType: Pro
 NativeFormatImporter:

MaterialGraphProject/Assets/_MingWai/Gradient.asset.meta

 fileFormatVersion: 2
-guid: 28805740b89754d4f87ecf03fa9a100d
+guid: b2d92851c9360294d858f87c2ff5e42d
 timeCreated: 1495750594
 licenseType: Pro
 NativeFormatImporter:

MaterialGraphProject/ProjectSettings/EditorSettings.asset

 --- !u!159 &1
 EditorSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 3
+  serializedVersion: 5
-  m_WebSecurityEmulationEnabled: 0
-  m_WebSecurityEmulationHostUrl: http://www.mydomain.com/mygame.unity3d
-  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd
+  m_EtcTextureCompressorBehavior: 0
+  m_EtcTextureFastCompressor: 0
+  m_EtcTextureNormalCompressor: 2
+  m_EtcTextureBestCompressor: 5
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;uss
+  m_UserGeneratedProjectSuffix: 
+  m_CollabEditorSettings:
+    inProgressEnabled: 1

MaterialGraphProject/ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 2017.2.0a1
+m_EditorVersion: 2017.3.0a1

MaterialGraphProject/Assets/Florent/UnityEngine.MaterialGraph.ExportTextureMasterNode8e1be5fc-7506-4529-879d-f1ce8c5aab04.mat.meta

+fileFormatVersion: 2
+guid: 34cd8c08793117743a70e155cc20695b
+timeCreated: 1499857151
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/ShaderGraph.meta

+fileFormatVersion: 2
+guid: 1678733d6c0ab1046b3f485042b3a7f7
+folderAsset: yes
+timeCreated: 1499856754
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/ShaderGraph/Textures.meta

+fileFormatVersion: 2
+guid: 97a3ddbc1b824e344bcb6c99a946e205
+folderAsset: yes
+timeCreated: 1499856755
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/IntegrationTests/Graphs/New Shader Graph 1.ShaderGraph

+{"m_SerializableNodes":[],"m_SerializableEdges":[],"m_ActiveMasterNodeGUIDSerialized":"a24f6342-6ad0-435a-8918-0cc483d83659"}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/IntegrationTests/Graphs/New Shader Graph 1.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 87ebd1179c598234faa4c7d160de0e69
+timeCreated: 1499938288
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Testing/IntegrationTests/Graphs/Test Shader Graph.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 2d2b482951ae9934eb58e29aad0367cc
+timeCreated: 1499934295
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures:
+  - Texture_Texture_50567049_Uniform: {fileID: 2800000, guid: e017404169662f041a969b0a924cc2ed,
+      type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/_MingWai/Gradient.ShaderGraph.meta

+fileFormatVersion: 2
+guid: a6f09a05d7731ad4b898124d9a681887
+timeCreated: 1499857140
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

README.md

+# Shader graph
+Unity branch: `editor/tech/events-draft/canvas2d/shadergraph`

MaterialGraphProject/Packages/Config/manifest.json

+{
+	"dependencies": {
+	}
+}

MaterialGraphProject/Packages/Config/manifest.json.meta

+fileFormatVersion: 2
+guid: 49bf290c29a827b4db5fa41af1124b2d
+timeCreated: 1499865694
+licenseType: Pro
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: