//----- method -----
public ExposedReferenceResolver(PlayableDirector playableDirector, ExposedReference <T> reference)
{
this.playableDirector = playableDirector;
this.reference = reference;
Resolve();
}
public static ExposedReference <T> DrawExposed(CutscenePlayer player, ExposedReference <T> value, GUIContent name,
Rect rect)
{
GUI.enabled = player != null;
var found = value.Resolve(player);
var label = GetLabel(found, value.exposedName, name);
var chosen = EditorGUI.ObjectField(rect, label, found, ReferenceType, true);
GUI.enabled = true;
if (player == null || chosen == found)
{
return(value);
}
//Remove old
player.SetReferenceValue(value.exposedName, null);
//If there is a new one, add it
if (chosen != null)
{
var newId = chosen.GetInstanceID().ToString();
value.exposedName = newId;
player.SetReferenceValue(newId, chosen);
}
return(value);
}
public void Play()
{
mControl.transform.position = playerControl.transform.position + playerControl.transform.rotation * offsetPos;
mControl.transform.rotation = Quaternion.LookRotation(playerControl.transform.position - mControl.transform.position);
mControl.transform.localEulerAngles += offsetRot;
mKillInfo.gameObject.SetActive(true);
mDirector.Play();
mDirector.SetGenericBinding(bindingDict["Player"].sourceObject, playerControl.mAim);
mDirector.SetGenericBinding(bindingDict["Enemy"].sourceObject, mControl.mAim);
mDirector.SetGenericBinding(bindingDict["Cinemachine"].sourceObject, Camera.main.GetComponent <Cinemachine.CinemachineBrain>());
var CinemachineTrack = bindingDict["Cinemachine"].sourceObject as Cinemachine.Timeline.CinemachineTrack;
foreach (var info in CinemachineTrack.GetClips())
{
if (info.displayName == "CinemachineShot")
{
var cameraInfo = info.asset as Cinemachine.Timeline.CinemachineShot;
var vcam1 = GameObject.Find("CM vcam1").GetComponent <CinemachineVirtualCameraBase>();
var setCam = new ExposedReference <CinemachineVirtualCameraBase>();
setCam.defaultValue = vcam1;
cameraInfo.VirtualCamera = setCam;
}
if (info.displayName == "CM vcam2")
{
var cameraInfo = info.asset as Cinemachine.Timeline.CinemachineShot;
var vcam2 = cameraInfo.VirtualCamera.Resolve(mDirector.playableGraph.GetResolver());
vcam2.LookAt = mControl.transform.Find("Tran_Chest").transform;
vcam2.Follow = mControl.transform;
}
}
}
public void Setup(PlayableDirector playableDirector)
{
TargetObject = new ExposedReferenceResolver <GameObject>(playableDirector, targetObject);
TargetObject.OnUpdateReferenceAsObservable()
.Subscribe(x => targetObject = x)
.AddTo(Disposable);
}
//Can be used to unlink an exposedReference after duplicating it.
internal static void RecreateReferenceInEditor <T>(ref ExposedReference <T> exposedRef,
IExposedPropertyTable table) where T : Object
{
T obj = exposedRef.Resolve(table);
exposedRef.exposedName = GUID.Generate().ToString();
table.SetReferenceValue(exposedRef.exposedName, obj);
}
public override void Serialize(ExposedReference <T> value, string name, SerializedObject destination)
{
var obj = new SerializedObject();
var id = value.exposedName.GetHashCode();
obj.SetInt(IdKey, id);
obj.SetUnity(DefaultKey, value.defaultValue);
destination.SetObject(name, obj);
}
internal static void SetReferenceValueInEditor <T>(ref ExposedReference <T> exposedRef,
IExposedPropertyTable propertyTable, T obj) where T : Object
{
//check if exposedName hasn't been initialized
if (exposedRef.exposedName.ToString() == ":0")
{
exposedRef.exposedName = GUID.Generate().ToString();
}
propertyTable.SetReferenceValue(exposedRef.exposedName, obj);
}
public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
{
var playable = ScriptPlayable <EventPlayableBehaviour> .Create(graph, inputCount : 0);
this.behaviour = playable.GetBehaviour();
this.behaviour.recipient = recipient.Resolve(graph.GetResolver());
this.behaviour.message = message;
this.behaviour.argument = getArgument();
return(playable);
}
//----- method -----
public void Setup(PlayableDirector playableDirector)
{
InvokeTarget = new ExposedReferenceResolver <GameObject>(playableDirector, invokeTarget);
InvokeTarget.OnUpdateReferenceAsObservable()
.Subscribe(x => invokeTarget = x)
.AddTo(Disposable);
if (argumentObjects != null)
{
foreach (var argumentObject in argumentObjects)
{
argumentObject.Setup(playableDirector);
}
}
}
public IEnumerator TestTimelineTrack()
{
director.Play();
exporter.MaxCaptureFrame = 30;
yield return(RecordAlembic());
deleteFileList.Add(exporter.Recorder.Settings.OutputPath);
var go = TestAbcImported(exporter.Recorder.Settings.OutputPath);
var root = PrefabUtility.InstantiatePrefab(go) as GameObject;
var player = root.GetComponent <AlembicStreamPlayer>();
var timeline = director.playableAsset as TimelineAsset;
var abcTrack = timeline.CreateTrack <AlembicTrack>(null, "");
var clip = abcTrack.CreateClip <AlembicShotAsset>();
var abcAsset = clip.asset as AlembicShotAsset;
var refAbc = new ExposedReference <AlembicStreamPlayer> {
exposedName = Guid.NewGuid().ToString()
};
abcAsset.StreamPlayer = refAbc;
director.SetReferenceValue(refAbc.exposedName, player);
director.RebuildGraph();
var cubeGO = root.GetComponentInChildren <MeshRenderer>().gameObject;
director.time = 0;
director.Evaluate();
yield return(null);
var t0 = cubeGO.transform.position;
director.time = player.Duration;
director.Evaluate();
yield return(null);
var t1 = cubeGO.transform.position;
Assert.AreNotEqual(t0, t1);
}
public override void Draw(CutsceneEditor editor, CutscenePlayer player, Cutscene cutscene, Rect rect, int tokenIndex, GUIContent name, ExposedReference <T> value, Type valueType, FieldInfo fieldInfo, Setter setter)
{
setter(DrawExposed(player, value, name, rect));
}
public ExposedAtmosphericScatteringReferenceParameter(
ExposedReference <AtmosphericScattering> value, bool overrideState = false)
: base(value, overrideState)
{
}
public ExposedAutoFocusReferenceParameter(ExposedReference <DepthOfFieldAutoFocus> value, bool overrideState = false)
: base(value, overrideState)
{
}
public ExposedWindControlReferenceParameter(ExposedReference <WindControl> value, bool overrideState = false)
: base(value, overrideState)
{
}
public ExposedLightReferenceParameter(ExposedReference <Light> value, bool overrideState = false)
: base(value, overrideState)
{
}
public CullingParameter(ExposedReference <LayerCulling> value, bool overrideState = false)
: base(value, overrideState)
{
}
