Resolved Confused about binding

Can you help us understand what is not working in this case?

 

The first script you shared works fine for me (the logged value of "ToggleValue" match the UI).
Which version of Unity are you using? It could be a bug that only exists in earlier versions.

 

Tested with 2 scenes, I don't think more would matter.

I don't know what could be wrong, I'd suggest submitting a bug.

In the mean time, could try to see if resolving the serialized property works?

I will share with the you the documentation page we are working on, related to exactly this topic.
In particular, the code for TexturePackEditor should be of interest to you. You can bind the toggle to a SerializedProperty instead of setting a binding path.
Specficially, look at how each property is bound with BindProperty(). Disregard the TexturePreviewElement class, it's just a bindable element just like Toggle. BindProperty() is an extension method.

The recommended way to bind UI to lists is to use the ListView element. However, it may not be suitable for all situations.

In order to manage a list directly, you can still leverage some of the functionality of the binding system, by interacting directly with the SerializedObject & SerializedProperty API. Specifically, each visual element can be bound to an item in the source array of the SerializedProperty object representing the array. You must also track the value of the array size in case it changes outside the UI (for example, doing “Reset” operation on asset or undoing).


The following example demonstrates how to create a ScrollView with an horizontal layout, where items can wrap to the next line when needed. This will operate inside a custom Editor for a new type of asset which holds textures that we use in our made up game.

To use this example, copy the scripts and assets below in your project and from the top menu select “Assets > Create > UIElementsExamples > TexturePackAsset”, then select the newly created asset. You might also want to import some textures and assign them to the different entries in the list. You can find some example textures in the free Playground asset store plugin: https://assetstore.unity.com/packages/essentials/tutorial-projects/unity-playground-109917


First, let’s define the TexturePackAsset which holds the list of textures:

Code (CSharp):

1. using System;
2. using System.Collections.Generic;
3. using UnityEngine;
4.  
5. [CreateAssetMenu(menuName = "UIElementsExamples/TexturePackAsset")]
6. public class TexturePackAsset : ScriptableObject
7. {
8.     public List<Texture2D> textures;
9.  
10.     public void Reset()
11.     {
12.         textures = new List<Texture2D>() { null, null, null, null };
13.     }
14. }

Then,we define a UI document which will be used in the Editor for TexturePackAsset.
It holds a ScrollView with a container where the list of UI elements for each texture will be added, and a Button which allows adding more entries to the list.

Code (CSharp):

1. <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xmlns="UnityEngine.UIElements" example="UIElementsExamples" editor-extension-mode="True">
2.     <ui:ScrollView>
3.         <ui:VisualElement class="preview-container" style="flex-wrap: wrap; flex-direction: row; justify-content: space-around;" />
4.     </ui:ScrollView>
5.     <ui:Button name="add-button" text="Add" />
6. </ui:UXML>

Each item of the list is represented by a TexturePreviewElement which is provided as part of the “Custom elements and data binding” section.

From the custom Editor for TexturePackAsset, we load this UI Document and populate it by iterating the list directly from the SerializedProperty, inside the SetupList() method.

In addition to populating the list when the Editor is first created, we must also track the size of the array. This is facilitated by using the TrackPropertyValue extension method which allows one to specify a callback function to be invoked whenever a property changes. In this case, we simply call the SetupList() method again.

This method provides the heavy lifting of keeping the container in synchronization with the SerializedProperty. Elements are reused or created as needed, and then bound directly to each property representing each item of the texture array.

Finally, we also add a callback to increase the size of the list. There are several ways to accomplish this, but one way is simply to increment the SerializedProperty.arraySize property.

The code for TexturePackEditor:

Code (CSharp):

1. using System;
2. using System.Linq;
3. using NUnit.Framework;
4. using UIElementsExamples;
5. using UnityEditor;
6. using UnityEditor.UIElements;
7. using UnityEngine;
8. using UnityEngine.Pool;
9. using UnityEngine.UIElements;
10.  
11. [CustomEditor(typeof(TexturePackAsset))]
12. public class TexturePackEditor : Editor
13. {
14.     public override VisualElement CreateInspectorGUI()
15.     {
16.         var visualTreeAsset = Resources.Load<VisualTreeAsset>("texture_pack_editor");
17.         var editor = visualTreeAsset.CloneTree();
18.    
19.         var container = editor.Q(className: "preview-container");
20.    
21.         SetupList(container);
22.    
23.         // Watch the array size to handle the list being changed    
24.         var propertyForSize = serializedObject.FindProperty(nameof(TexturePackAsset.textures) + ".Array");
25.         propertyForSize.Next(true); // Expand to obtain array size
26.         editor.TrackPropertyValue(propertyForSize, prop => SetupList(container));
27.    
28.         editor.Q<Button>("add-button").RegisterCallback<ClickEvent>(OnClick);
29.  
30.         return editor;
31.     }
32.  
33.     void SetupList(VisualElement container)
34.     {
35.         var property = serializedObject.FindProperty(nameof(TexturePackAsset.textures) + ".Array");
36.  
37.         var endProperty = property.GetEndProperty();
38.  
39.         property.NextVisible(true); // Expand the first child.
40.  
41.         int childIndex = 0;
42.    
43.         // Iterate each property under the array and populate the container with preview elements
44.         do
45.         {
46.             // Stop if we've reached the end of the array
47.             if (SerializedProperty.EqualContents(property, endProperty))
48.                 break;
49.  
50.             // Skip the array size property
51.             if (property.propertyType == SerializedPropertyType.ArraySize)
52.                 continue;
53.  
54.             TexturePreviewElement element;
55.  
56.             // Find an existing element or create one
57.             if (childIndex < container.childCount)
58.             {
59.                 element = (TexturePreviewElement)container[childIndex];
60.             }
61.             else
62.             {
63.                 element = new TexturePreviewElement();
64.                 container.Add(element);
65.             }
66.  
67.             element.BindProperty(property);
68.  
69.             ++childIndex;
70.         }
71.         while (property.NextVisible(false));   // Never expand children.
72.    
73.         // Remove excess elements if the array is now smaller
74.         while (childIndex < container.childCount)
75.         {
76.             container.RemoveAt(container.childCount-1);
77.         }
78.     }
79.  
80.     void OnClick(ClickEvent evt)
81.     {
82.         var property = serializedObject.FindProperty(nameof(TexturePackAsset.textures));
83.         property.arraySize += 1;
84.         serializedObject.ApplyModifiedProperties();
85.     }
86. }

 

I am using 2022.1.
The fact that this returns null means that the issue is with the property path. I am not sure why that would be, but iterating the children of the "_sceneList" SerializedProperty would probably work, instead of reconstructing the full path by hand.