private void Start()
{
mixers = new List <AnimationLayerMixerPlayable>();
for (var i = 0; i < dir.playableGraph.GetOutputCount(); i++)
{
var p = dir.playableGraph.GetRootPlayable(i);
if (!p.IsValid())
{
continue;
}
Debug.Log(p.GetPlayableType());
Debug.Log("OUTPUT: " + i + " = " + p.GetPlayableType() + ", outputs: " + p.GetOutputCount() + ", inputs: " + p.GetInputCount());
Traverse(p, mixers);
}
var arr = dir.playableAsset.outputs.ToArray();
for (var i = 0; i < arr.Length; i++)
{
var entry = arr[i];
if (entry.outputTargetType == typeof(Animator))
{
var binding = dir.GetGenericBinding(entry.sourceObject);
var b2 = dir.GetReferenceValue(new PropertyName(entry.streamName), out var valid);
Debug.Log("BINDING: " + i + ", " + binding + ", " + b2 + " valid=" + valid + " " + entry.streamName + " - " + entry.sourceObject +
", " + binding);
boundAnimators.Add(binding as Animator);
}
else
{
var binding = dir.GetGenericBinding(entry.sourceObject);
var b2 = dir.GetReferenceValue(new PropertyName(entry.streamName), out var valid);
Debug.Log("BINDING: " + i + " is " + entry.outputTargetType + " for " + b2 + ", " + entry.streamName + ", " + binding);
}
}
if (InjectOnStart)
{
InjectMixers();
}
Debug.Log("-----------");
if (TimelineUtilities.TryFindTimelinePlayable(dir.playableGraph, out var timeline))
{
Debug.Log(timeline.GetPlayableType() + ", " + timeline.GetType());
if (TimelineUtilities.TryInjectMixer(dir, timeline, GetComponent <Animator>(), out var mixer))
{
Debug.Log("INJECTED MIXER" + mixer);
}
}
}
// get the game object reference associated with this
public static GameObject GetSceneGameObject(PlayableDirector director, TrackAsset asset)
{
if (director == null || asset == null)
return null;
asset = GetSceneReferenceTrack(asset);
var gameObject = director.GetGenericBinding(asset) as GameObject;
var component = director.GetGenericBinding(asset) as Component;
if (component != null)
gameObject = component.gameObject;
return gameObject;
}
public static Animator GetAnimator(TrackAsset asset, PlayableDirector director)
{
AnimationTrack animationTrack = asset as AnimationTrack;
Animator result;
if (animationTrack != null && !animationTrack.isSubTrack)
{
Object genericBinding = director.GetGenericBinding(animationTrack);
if (genericBinding == null)
{
result = null;
}
else
{
Animator animator = genericBinding as Animator;
GameObject gameObject = genericBinding as GameObject;
if (animator == null && gameObject != null)
{
animator = gameObject.GetComponent <Animator>();
}
result = animator;
}
}
else
{
result = null;
}
return(result);
}
public void GenerateMoveClip(PlayableDirector director, int trackIndex)
{
List <CurvePoint> points = GetPointsInScene();
if (points.Count <= 0)
{
return;
}
string errorLog = "";
TimelineAsset asset = director.playableAsset as TimelineAsset;
TrackAsset track = asset.GetOutputTrack(trackIndex);
if (track == null)
{
errorLog = "Track Index Error";
}
if (!(track is RoleMoveTrack))
{
errorLog = "Track 类型错误，不是RoleMoveTrack";
}
if (string.IsNullOrEmpty(errorLog))
{
List <Vector3> pointsPos = points.Select(point => point.transform.position).ToList();
TimelineClip clip = track.CreateDefaultClip();
RoleMoveClip moveclip = clip.asset as RoleMoveClip;
moveclip.points = pointsPos;
moveclip.roleData = director.GetGenericBinding(track) as RoleData;
}
else
{
Debug.LogError(errorLog);
}
}
internal Animator GetBinding(PlayableDirector director)
{
if (director == null)
{
return(null);
}
UnityEngine.Object key = this;
if (isSubTrack)
{
key = parent;
}
UnityEngine.Object binding = null;
if (director != null)
{
binding = director.GetGenericBinding(key);
}
Animator animator = null;
if (binding != null) // the binding can be an animator or game object
{
animator = binding as Animator;
var gameObject = binding as GameObject;
if (animator == null && gameObject != null)
{
animator = gameObject.GetComponent <Animator>();
}
}
return(animator);
}
private Material GetClipBoundMaterial()
{
PlayableDirector selectedDirector = TimelineEditor.inspectedDirector;
MaterialParamTrack track = base.target as MaterialParamTrack;
if (selectedDirector != null && track != null)
{
ParentBindingTrack parentTrack = track.parent as ParentBindingTrack;
if (parentTrack != null)
{
Object binding = parentTrack.GetEditorBinding(selectedDirector);
if (binding is Material material)
{
return(material);
}
}
else
{
return(selectedDirector.GetGenericBinding(track) as Material);
}
}
return(null);
}
private void Start()
{
if (!director)
{
if (GetComponent <PlayableDirector>())
{
director = GetComponent <PlayableDirector>();
}
}
// 타임라인에 오브젝트 바인딩. Interact_Window.cs->Start() 참고.
if (GameObject.FindWithTag("Player"))
{
GameObject player = GameObject.FindWithTag("Player");
// 캐비닛에 들어가는 타임라인.
TimelineAsset tmp = director.playableAsset as TimelineAsset;
director.SetGenericBinding(tmp.GetOutputTrack(0), player);
tmp = bossAndDoctor.playableAsset as TimelineAsset;
// Interact_Window.cs에서 보스와닥터 타임라인에 플레이어 카메라를 할당을 하나, 만약으로 안되어 있을 경우.
if (bossAndDoctor.GetGenericBinding(tmp.GetOutputTrack(2)) == null)
{
bossAndDoctor.SetGenericBinding(tmp.GetOutputTrack(2), player.GetComponentInChildren <Camera>().gameObject);
}
}
}
/**
* <summary>Serialises appropriate GameObject values into a string.</summary>
* <returns>The data, serialised as a string</returns>
*/
public override string SaveData()
{
TimelineData timelineData = new TimelineData();
timelineData.objectID = constantID;
timelineData.savePrevented = savePrevented;
#if UNITY_2017_1_OR_NEWER
PlayableDirector director = GetComponent <PlayableDirector>();
timelineData.isPlaying = (director.state == PlayState.Playing);
timelineData.currentTime = director.time;
timelineData.trackObjectData = "";
timelineData.timelineAssetID = "";
if (director.playableAsset != null)
{
TimelineAsset timeline = (TimelineAsset)director.playableAsset;
if (timeline != null)
{
if (saveTimelineAsset)
{
timelineData.timelineAssetID = AssetLoader.GetAssetInstanceID(timeline);
}
if (saveBindings)
{
int[] bindingIDs = new int[timeline.outputTrackCount];
for (int i = 0; i < bindingIDs.Length; i++)
{
TrackAsset trackAsset = timeline.GetOutputTrack(i);
GameObject trackObject = director.GetGenericBinding(trackAsset) as GameObject;
bindingIDs[i] = 0;
if (trackObject != null)
{
ConstantID cIDComponent = trackObject.GetComponent <ConstantID>();
if (cIDComponent != null)
{
bindingIDs[i] = cIDComponent.constantID;
}
}
}
for (int i = 0; i < bindingIDs.Length; i++)
{
timelineData.trackObjectData += bindingIDs[i].ToString();
if (i < (bindingIDs.Length - 1))
{
timelineData.trackObjectData += ",";
}
}
}
}
}
#else
ACDebug.LogWarning("The 'Remember Director' component is only compatible with Unity 5.6 onward.", this);
#endif
return(Serializer.SaveScriptData <TimelineData> (timelineData));
}
//----------------------------------------------------------------------------------------------------------------------
protected override Playable CreateTrackMixerInternal(PlayableGraph graph, GameObject go, int inputCount)
{
InitTrackCurves();
var mixer = ScriptPlayable <StreamingImageSequencePlayableMixer> .Create(graph, inputCount);
PlayableDirector director = go.GetComponent <PlayableDirector>();
m_trackMixer = mixer.GetBehaviour();
if (director != null)
{
Object boundObject = director.GetGenericBinding(this);
StreamingImageSequenceRenderer renderer = boundObject as StreamingImageSequenceRenderer;
if (null == renderer)
{
//no object bound to the track
m_trackMixer.Init(null, director, GetClips());
}
else
{
m_trackMixer.Init(renderer.gameObject, director, GetClips());
renderer.Init();
m_trackMixer.SetRenderer(renderer);
}
}
return(mixer);
}
static GameObject GetBoundGameObject(TrackAsset parent, PlayableDirector associatedDirector)
{
if (parent == null || parent.Equals(null) || associatedDirector == null)
{
return(null);
}
var binding = associatedDirector.GetGenericBinding(parent);
// We are the markerTrack and user did not set a binding, assume it's bound to PlayableDirector
if (parent.timelineAsset.markerTrack == parent && binding == null)
{
return(associatedDirector.gameObject);
}
if (binding == null || binding.Equals(null))
{
return(null);
}
var boundGameObject = binding as GameObject;
if (boundGameObject == null)
{
var boundComponent = binding as Component;
if (boundComponent != null)
{
boundGameObject = boundComponent.gameObject;
}
}
return(boundGameObject);
}
internal static void DuplicateBindings(TrackAsset track, TrackAsset newTrack, PlayableDirector director)
{
var originalTracks = track.GetFlattenedChildTracks().Append(track);
var newTracks = newTrack.GetFlattenedChildTracks().Append(newTrack);
var toBind = new List <Tuple <TrackAsset, Object> >();
// Collect all track bindings to duplicate
var originalIt = originalTracks.GetEnumerator();
var newIt = newTracks.GetEnumerator();
while (originalIt.MoveNext() && newIt.MoveNext())
{
var binding = director.GetGenericBinding(originalIt.Current);
if (binding != null)
{
toBind.Add(new Tuple <TrackAsset, Object>(newIt.Current, binding));
}
}
//Only create Director undo if there are bindings to duplicate
if (toBind.Count > 0)
{
TimelineUndo.PushUndo(TimelineEditor.inspectedDirector, L10n.Tr("Duplicate"));
}
//Assign bindings for all tracks after undo.
foreach (var binding in toBind)
{
TimelineEditor.inspectedDirector.SetGenericBinding(binding.Item1, binding.Item2);
}
}
internal GameObject GetGameObjectBinding(PlayableDirector director)
{
if (director == null)
{
return(null);
}
var binding = director.GetGenericBinding(this);
var gameObject = binding as GameObject;
if (gameObject != null)
{
return(gameObject);
}
var comp = binding as Component;
if (comp != null)
{
return(comp.gameObject);
}
return(null);
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
//
// In this track, the following properties will be modified.
//
// - transform.position
// - transform.rotation
// - particleSystem.useAutoRandomSeed
// - particleSystem.main.duration
// - particleSystem.emission.rateOverTimeMultiplier
// - particleSystem.emission.rateOverDistanceMultiplier
//
// Note that the serialized property names are a bit defferent from
// their property name.
//
var ps = director.GetGenericBinding(this) as ParticleSystem;
if (ps == null)
{
return;
}
var go = ps.gameObject;
driver.AddFromName <Transform>(go, "m_LocalPosition");
driver.AddFromName <Transform>(go, "m_LocalRotation");
driver.AddFromName <ParticleSystem>(go, "lengthInSec");
driver.AddFromName <ParticleSystem>(go, "autoRandomSeed");
driver.AddFromName <ParticleSystem>(go, "randomSeed");
driver.AddFromName <ParticleSystem>(go, "EmissionModule.rateOverTime.scalar");
driver.AddFromName <ParticleSystem>(go, "EmissionModule.rateOverDistance.scalar");
}
//得到轨道绑定对象的GameObject
public GameObject GetObj(PlayableDirector Director, UnityEngine.Object sourceObject)
{
GameObject obj = null;
UnityEngine.Object a = (UnityEngine.Object)Director.GetGenericBinding(sourceObject);
if (a is GameObject)
{
obj = (GameObject)a;
}
else if (a is Graphic)
{
Graphic ui = (Graphic)a;
obj = ui.rectTransform.gameObject;
}
else if (a is CinemachineBrain)
{
CinemachineBrain cina = (CinemachineBrain)a;
obj = cina.gameObject;
}
else if (a is Component)
{
Component cina = (Component)a;
obj = cina.gameObject;
}
return(obj);
}
internal GameObject GetGameObjectBinding(PlayableDirector director)
{
GameObject result;
if (director == null)
{
result = null;
}
else
{
Object genericBinding = director.GetGenericBinding(this);
GameObject gameObject = genericBinding as GameObject;
if (gameObject != null)
{
result = gameObject;
}
else
{
Component component = genericBinding as Component;
if (component != null)
{
result = component.gameObject;
}
else
{
result = null;
}
}
}
return(result);
}
private void OnSkipClick(PlayableDirector director)
{
director.Stop();
List <RoleData> loadedRoleData = new List <RoleData>();
foreach (var binding in director.playableAsset.outputs)
{
if (binding.sourceObject is MYCinemachineTrack)
{
SetCinemachineTrackData(binding, director);
continue;
}
UnityEngine.Object bindingObj = director.GetGenericBinding(binding.sourceObject);
if (bindingObj != null && bindingObj is RoleData)
{
RoleData roledata = bindingObj as RoleData;
if (!loadedRoleData.Contains(roledata))
{
loadedRoleData.Add(roledata);
RoleObject role = roledata.Role as RoleObject;
if (role != null && role.gameObject != null && roledata.TargetPosWhenSkip != Vector3.zero)
{
role.gameObject.transform.position = roledata.TargetPosWhenSkip;
}
}
}
}
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
#if false
#if UNITY_EDITOR
Light trackBinding = director.GetGenericBinding(this) as Light;
if (trackBinding == null)
{
return;
}
var serializedObject = new UnityEditor.SerializedObject(trackBinding);
var iterator = serializedObject.GetIterator();
while (iterator.NextVisible(true))
{
if (iterator.hasVisibleChildren)
{
continue;
}
driver.AddFromName <Light>(trackBinding.gameObject, iterator.propertyPath);
}
#endif
#endif
base.GatherProperties(director, driver);
}
private SkinnedMeshRenderer GetClipBoundSkinnedMeshRenderer()
{
PlayableDirector selectedDirector = TimelineEditor.inspectedDirector;
SkinnedMeshBlendshapeTrack track = base.target as SkinnedMeshBlendshapeTrack;
if (selectedDirector != null && track != null)
{
ParentBindingTrack parentTrack = track.parent as ParentBindingTrack;
if (parentTrack != null)
{
Object binding = parentTrack.GetEditorBinding(selectedDirector);
if (binding is GameObject)
{
return(SkinnedMeshBlendshapeTrack.GetSkinnedMeshFromGameObject((GameObject)binding));
}
else if (binding is Transform)
{
return(SkinnedMeshBlendshapeTrack.GetSkinnedMeshFromGameObject(((Transform)binding).gameObject));
}
}
else
{
return(selectedDirector.GetGenericBinding(track) as SkinnedMeshRenderer);
}
}
return(null);
}
public static List <Object> CloneTrack(this PlayableDirector self, PlayableDirector dest, string trackName)
{
List <Object> toRemoveList = new List <Object>();
TimelineAsset sourceTimelineAsset = (TimelineAsset)self.playableAsset;
TimelineAsset cloneTimelineAsset = sourceTimelineAsset.CloneTrackAsset(trackName);
dest.playableAsset = cloneTimelineAsset;
toRemoveList.Add(cloneTimelineAsset);
Object sourceBinding = self.GetGenericBinding(sourceTimelineAsset.GetTrackAsset(trackName));
if (sourceBinding != null)
{
Object clone_binding;
if (sourceBinding is Component c)
{
GameObject cloneBindingGameObject = Object.Instantiate(c.gameObject);
cloneBindingGameObject.transform.CopyFrom(c.transform);
clone_binding = cloneBindingGameObject.GetComponent(c.GetType());
toRemoveList.Add(cloneBindingGameObject);
}
else
{
clone_binding = Object.Instantiate(sourceBinding);
toRemoveList.Add(clone_binding);
}
clone_binding.name = StringUtilCat.RoundBrackets(StringConst.String_clone) + sourceBinding.name;
dest.SetGenericBinding(cloneTimelineAsset.GetTrackAsset(trackName), clone_binding);
}
return(toRemoveList);
}
private Animator GetClipBoundAnimator()
{
PlayableDirector selectedDirector = TimelineEditor.inspectedDirector;
AnimatorParamTrack track = base.target as AnimatorParamTrack;
if (selectedDirector != null && track != null)
{
ParentBindingTrack parentTrack = track.parent as ParentBindingTrack;
if (parentTrack != null)
{
Object binding = parentTrack.GetEditorBinding(selectedDirector);
if (binding is GameObject)
{
return(AnimatorParamTrack.GetAnimatorFromGameObject((GameObject)binding));
}
else if (binding is Transform)
{
return(AnimatorParamTrack.GetAnimatorFromGameObject(((Transform)binding).gameObject));
}
}
else
{
return(selectedDirector.GetGenericBinding(track) as Animator);
}
}
return(null);
}
/**
* <summary>Serialises appropriate GameObject values into a string.</summary>
* <returns>The data, serialised as a string</returns>
*/
public override string SaveData()
{
TimelineData timelineData = new TimelineData();
timelineData.objectID = constantID;
timelineData.savePrevented = savePrevented;
PlayableDirector director = GetComponent <PlayableDirector>();
timelineData.isPlaying = (director.state == PlayState.Playing);
timelineData.currentTime = director.time;
timelineData.trackObjectData = string.Empty;
timelineData.timelineAssetID = string.Empty;
if (director.playableAsset != null)
{
#if !ACIgnoreTimeline
TimelineAsset timeline = (TimelineAsset)director.playableAsset;
if (timeline != null)
{
if (saveTimelineAsset)
{
timelineData.timelineAssetID = AssetLoader.GetAssetInstanceID(timeline);
}
if (saveBindings)
{
int[] bindingIDs = new int[timeline.outputTrackCount];
for (int i = 0; i < bindingIDs.Length; i++)
{
TrackAsset trackAsset = timeline.GetOutputTrack(i);
GameObject trackObject = director.GetGenericBinding(trackAsset) as GameObject;
bindingIDs[i] = 0;
if (trackObject != null)
{
ConstantID cIDComponent = trackObject.GetComponent <ConstantID>();
if (cIDComponent != null)
{
bindingIDs[i] = cIDComponent.constantID;
}
}
}
for (int i = 0; i < bindingIDs.Length; i++)
{
timelineData.trackObjectData += bindingIDs[i].ToString();
if (i < (bindingIDs.Length - 1))
{
timelineData.trackObjectData += ",";
}
}
}
}
#endif
}
return(Serializer.SaveScriptData <TimelineData> (timelineData));
}
protected override Playable CreatePlayable(PlayableGraph graph, GameObject go, TimelineClip clip)
{
RoleEffectClip effectClip = clip.asset as RoleEffectClip;
PlayableDirector director = go.GetComponent <PlayableDirector>();
effectClip.roleData = director.GetGenericBinding(this) as RoleData;
return(base.CreatePlayable(graph, go, clip));
}
public override void OnInspectorGUI()
{
BoneFxAsset asset = target as BoneFxAsset;
if (director == null)
{
director = GameObject.FindObjectOfType <PlayableDirector>();
}
EditorGUILayout.Space();
prefabGo = EditorGUILayout.ObjectField("Fx Prefab", prefabGo, typeof(GameObject), true) as GameObject;
if (prefabGo != null)
{
string path = AssetDatabase.GetAssetPath(prefabGo);
asset.prefab = path.Replace("Assets/BundleRes/", string.Empty).Replace(".prefab", string.Empty);
if (!path.Contains("BundleRes") || !path.EndsWith(".prefab"))
{
EditorGUILayout.HelpBox("The fx that you selected is invalid", MessageType.Error);
}
}
if (boneGo == null && !string.IsNullOrEmpty(asset.prefab))
{
string path = "Assets/BundleRes/" + asset.prefab + ".prefab";
prefabGo = AssetDatabase.LoadAssetAtPath <GameObject>(path);
if (prefabGo == null)
{
EditorGUILayout.HelpBox("AssetPath is invalid", MessageType.Error);
}
}
EditorGUILayout.LabelField(asset.prefab);
boneGo = EditorGUILayout.ObjectField("Select Bone", boneGo, typeof(GameObject), true) as GameObject;
EditorGUILayout.LabelField(asset.fxPath);
if (boneGo != null)
{
asset.fxPath = GetRootFullPath(boneGo.transform);
if (string.IsNullOrEmpty(asset.fxPath) || !asset.fxPath.StartsWith("root"))
{
EditorGUILayout.HelpBox("Avatar bone transform is invalid", MessageType.Error);
}
}
else if (!string.IsNullOrEmpty(asset.fxPath))
{
if (asset.track != null)
{
var binding = director.GetGenericBinding(asset.track);
Transform tf = ExternalHelp.FetchAttachOfTrack(director, asset.track);
if (tf)
{
tf = tf.GetChild(0).Find(asset.fxPath);
if (tf)
{
boneGo = tf.gameObject;
}
}
}
}
DrawTransform();
PreviewFx();
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
SkeletonAnimation skeletonAnimation = (SkeletonAnimation)director.GetGenericBinding(this);
if (skeletonAnimation != null)
{
driver.AddFromName <SkeletonAnimation>(skeletonAnimation.gameObject, "m_Enabled");
}
}
protected override Playable CreatePlayable(PlayableGraph graph, GameObject go, TimelineClip clip)
{
ObjectScaleControlClip clipAsset = clip.asset as ObjectScaleControlClip;
PlayableDirector dirctor = go.GetComponent <PlayableDirector>();
var binding = dirctor.GetGenericBinding(this) as RoleData;
clipAsset.role = binding;
return(base.CreatePlayable(graph, go, clip));
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
SkeletonGraphic skeletonGraphic = (SkeletonGraphic)director.GetGenericBinding(this);
if (skeletonGraphic != null)
{
driver.AddFromName <SkeletonGraphic>(skeletonGraphic.gameObject, "freeze");
}
}
public override void OnInspectorGUI()
{
var signal = target as Signal;
if (signal == null)
{
return;
}
signal.name = GUILayout.TextField(signal.name);
base.OnInspectorGUI();
PlayableDirector inspectedDirector = TimelineEditor.inspectedDirector;
if (inspectedDirector == null)
{
EditorGUILayout.HelpBox("Select Playable Director to setup signal response", MessageType.Info);
return;
}
if (signal.parent == signal.parent.timelineAsset.markerTrack)
{
_boundGameObject = inspectedDirector.gameObject;
}
else
{
Object genericBinding = inspectedDirector.GetGenericBinding(signal.parent);
if (genericBinding is GameObject gameObject)
{
_boundGameObject = gameObject;
}
if (genericBinding is Component component)
{
_boundGameObject = component.gameObject;
}
}
if (_boundGameObject == null)
{
return;
}
SignalHandlerBase[] signalHandlers = _boundGameObject.GetComponents <SignalHandlerBase>()
.Where(handler => handler.SignalType.IsInstanceOfType(signal))
.ToArray();
if (signalHandlers.Length == 0 && GUILayout.Button("Add Signal Handler"))
{
_boundGameObject.gameObject.AddComponent <SignalHandler>();
}
foreach (SignalHandlerBase signalHandler in signalHandlers)
{
EditorGUILayout.Separator();
Editor editor = GetOrCreateEditor(signalHandler);
if (DrawReceiverHeader(signalHandler))
{
editor.OnInspectorGUI();
}
}
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
#if UNITY_EDITOR
FacialExpressionTimeline trackBinding = director.GetGenericBinding(this) as FacialExpressionTimeline;
if (trackBinding == null)
{
return;
}
#endif
}
protected override Playable CreatePlayable(PlayableGraph graph, GameObject go, TimelineClip clip)
{
PlayableDirector director = go.GetComponent <PlayableDirector>();
RoleMoveClip moveClip = clip.asset as RoleMoveClip;
moveClip.roleData = (RoleData)director.GetGenericBinding(clip.parentTrack);
Playable playable = base.CreatePlayable(graph, go, clip);
return(playable);
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
var binding = director.GetGenericBinding(this) as Transform;
if (binding == null)
{
return;
}
driver.AddFromName <Transform>(binding.gameObject, "m_LocalPosition");
base.GatherProperties(director, driver);
}
