TrackEditor.cs
10.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
using System;
using System.Linq;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Timeline;
namespace UnityEditor.Timeline
{
/// <summary>
/// The user-defined options for drawing a track."
/// </summary>
public struct TrackDrawOptions
{
/// <summary>
/// Text that indicates if the track should display an error.
/// </summary>
/// <remarks>
/// If the error text is not empty or null, then the track displays a warning. The error text is used as the tooltip.
/// </remarks>
public string errorText { get; set; }
/// <summary>
/// The highlight color of the track.
/// </summary>
public Color trackColor { get; set; }
/// <summary>
/// The minimum height of the track.
/// </summary>
public float minimumHeight { get; set; }
/// <summary>
/// The icon displayed on the track header.
/// </summary>
/// <remarks>
/// If this value is null, then the default icon for the track is used.
/// </remarks>
public Texture2D icon { get; set; }
public override bool Equals(object obj)
{
if (!(obj is TrackDrawOptions))
return false;
return Equals((TrackDrawOptions)obj);
}
public bool Equals(TrackDrawOptions other)
{
return errorText == other.errorText &&
trackColor == other.trackColor &&
minimumHeight == other.minimumHeight &&
icon == other.icon;
}
public override int GetHashCode()
{
return HashUtility.CombineHash(
errorText != null ? errorText.GetHashCode() : 0,
trackColor.GetHashCode(),
minimumHeight.GetHashCode(),
icon != null ? icon.GetHashCode() : 0
);
}
public static bool operator==(TrackDrawOptions options1, TrackDrawOptions options2)
{
return options1.Equals(options2);
}
public static bool operator!=(TrackDrawOptions options1, TrackDrawOptions options2)
{
return !options1.Equals(options2);
}
}
/// <summary>
/// The errors displayed for the track binding.
/// </summary>
public enum TrackBindingErrors
{
/// <summary>
/// Select no errors.
/// </summary>
None = 0,
/// <summary>
/// The bound GameObject is disabled.
/// </summary>
BoundGameObjectDisabled = 1 << 0,
/// <summary>
/// The bound GameObject does not have a valid component.
/// </summary>
NoValidComponent = 1 << 1,
/// <summary>
/// The bound Object is a disabled Behaviour.
/// </summary>
BehaviourIsDisabled = 1 << 2,
/// <summary>
/// The bound Object is not of the correct type.
/// </summary>
InvalidBinding = 1 << 3,
/// <summary>
/// The bound Object is part of a prefab, and not an instance.
/// </summary>
PrefabBound = 1 << 4,
/// <summary>
/// Select all errors.
/// </summary>
All = Int32.MaxValue
}
/// <summary>
/// Use this class to customize track types in the TimelineEditor.
/// </summary>
public class TrackEditor
{
static readonly string k_BoundGameObjectDisabled = LocalizationDatabase.GetLocalizedString("The bound GameObject is disabled.");
static readonly string k_NoValidComponent = LocalizationDatabase.GetLocalizedString("Could not find appropriate component on this gameObject");
static readonly string k_RequiredComponentIsDisabled = LocalizationDatabase.GetLocalizedString("The component is disabled");
static readonly string k_InvalidBinding = LocalizationDatabase.GetLocalizedString("The bound object is not the correct type.");
static readonly string k_PrefabBound = LocalizationDatabase.GetLocalizedString("The bound object is a Prefab");
readonly Dictionary<TrackAsset, System.Type> m_BindingCache = new Dictionary<TrackAsset, System.Type>();
/// <summary>
/// The default height of a track.
/// </summary>
public static readonly float DefaultTrackHeight = 30.0f;
/// <summary>
/// The minimum unscaled height of a track.
/// </summary>
public static readonly float MinimumTrackHeight = 10.0f;
/// <summary>
/// The maximum height of a track.
/// </summary>
public static readonly float MaximumTrackHeight = 256.0f;
/// <summary>
/// Implement this method to override the default options for drawing a track.
/// </summary>
/// <param name="track">The track from which track options are retrieved.</param>
/// <param name="binding">The binding for the track.</param>
/// <returns>The options for drawing the track.</returns>
public virtual TrackDrawOptions GetTrackOptions(TrackAsset track, UnityEngine.Object binding)
{
return new TrackDrawOptions()
{
errorText = GetErrorText(track, binding, TrackBindingErrors.All),
minimumHeight = DefaultTrackHeight,
trackColor = GetTrackColor(track),
icon = null
};
}
/// <summary>
/// Gets the error text for the specified track.
/// </summary>
/// <param name="track">The track to retrieve options for.</param>
/// <param name="boundObject">The binding for the track.</param>
/// <param name="detectErrors">The errors to check for.</param>
/// <returns>An error to be displayed on the track, or string.Empty if there is no error.</returns>
public string GetErrorText(TrackAsset track, UnityEngine.Object boundObject, TrackBindingErrors detectErrors)
{
if (track == null || boundObject == null)
return string.Empty;
var bindingType = GetBindingType(track);
if (bindingType != null)
{
// bound to a prefab asset
if (HasFlag(detectErrors, TrackBindingErrors.PrefabBound) && PrefabUtility.IsPartOfPrefabAsset(boundObject))
{
return k_PrefabBound;
}
// If we are a component, allow for bound game objects (legacy)
if (typeof(Component).IsAssignableFrom(bindingType))
{
var gameObject = boundObject as GameObject;
var component = boundObject as Component;
if (component != null)
gameObject = component.gameObject;
// game object is bound with no component
if (HasFlag(detectErrors, TrackBindingErrors.NoValidComponent) && gameObject != null && component == null)
{
component = gameObject.GetComponent(bindingType);
if (component == null)
{
return k_NoValidComponent;
}
}
// attached gameObject is disables (ignores Activation Track)
if (HasFlag(detectErrors, TrackBindingErrors.BoundGameObjectDisabled) && gameObject != null && !gameObject.activeInHierarchy)
{
return k_BoundGameObjectDisabled;
}
// component is disabled
var behaviour = component as Behaviour;
if (HasFlag(detectErrors, TrackBindingErrors.BehaviourIsDisabled) && behaviour != null && !behaviour.enabled)
{
return k_RequiredComponentIsDisabled;
}
// mismatched binding
if (HasFlag(detectErrors, TrackBindingErrors.InvalidBinding) && component != null && !bindingType.IsAssignableFrom(component.GetType()))
{
return k_InvalidBinding;
}
}
// Mismatched binding (non-component)
else if (HasFlag(detectErrors, TrackBindingErrors.InvalidBinding) && !bindingType.IsAssignableFrom(boundObject.GetType()))
{
return k_InvalidBinding;
}
}
return string.Empty;
}
/// <summary>
/// Gets the color information of a track.
/// </summary>
/// <param name="track"></param>
/// <returns>Returns the color for the specified track.</returns>
public Color GetTrackColor(TrackAsset track)
{
return TrackResourceCache.GetTrackColor(track);
}
/// <summary>
/// Gets the binding type for a track.
/// </summary>
/// <param name="track">The track to retrieve the binding type from.</param>
/// <returns>Returns the binding type for the specified track. Returns null if the track does not have binding.</returns>
public System.Type GetBindingType(TrackAsset track)
{
if (track == null)
return null;
System.Type result = null;
if (m_BindingCache.TryGetValue(track, out result))
return result;
result = track.outputs.Select(x => x.outputTargetType).FirstOrDefault();
m_BindingCache[track] = result;
return result;
}
/// <summary>
/// Callback for when a track is created.
/// </summary>
/// <param name="track">The track that is created.</param>
/// <param name="copiedFrom">The source that the track is copied from. This can be set to null if the track is not a copy.</param>
public virtual void OnCreate(TrackAsset track, TrackAsset copiedFrom)
{
}
/// <summary>
/// Callback for when a track is changed.
/// </summary>
/// <param name="track">The track that is changed.</param>
public virtual void OnTrackChanged(TrackAsset track)
{
}
private static bool HasFlag(TrackBindingErrors errors, TrackBindingErrors flag)
{
return (errors & flag) != 0;
}
}
}