//----------------------------------------------------------------------------------------------------------------------
/// <inheritdoc/>
public override ClipDrawOptions GetClipOptions(TimelineClip clip) {
ClipDrawOptions clipOptions = base.GetClipOptions(clip);
SceneCachePlayableAsset asset = clip.asset as SceneCachePlayableAsset;
if (null == asset) {
Debug.LogError("Asset is not a SceneCachePlayableAsset: " + clip.asset);
return clipOptions;
}
SceneCacheClipData clipData = asset.GetBoundClipData();
if (null == clipData)
return clipOptions;
SceneCachePlayer scPlayer = asset.GetSceneCachePlayer();
if (null == scPlayer) {
clipOptions.errorText = NO_SCENE_CACHE_ASSIGNED_ERROR;
return clipOptions;
}
LimitedAnimationController overrideLimitedAnimationController =asset.GetOverrideLimitedAnimationController();
if (!scPlayer.IsLimitedAnimationOverrideable() && overrideLimitedAnimationController.IsEnabled()) {
clipOptions.errorText = UNABLE_TO_OVERRIDE_LIMITED_ANIMATION_ERROR;
return clipOptions;
}
clipOptions.tooltip = scPlayer.GetSceneCacheFilePath();
return clipOptions;
}
public IEnumerator EnsureMatchingAndLimitedFramesAreLoadedToScene()
{
InitTest(true, out PlayableDirector director, out SceneCachePlayer sceneCachePlayer, out TimelineClip clip0);
yield return(null);
ISceneCacheInfo scInfo = sceneCachePlayer.ExtractSceneCacheInfo(forceOpen: true);
Assert.IsNotNull(scInfo);
int numFrames = scInfo.GetNumFrames();
double timePerFrame = 1.0f / scInfo.GetSampleRate();
//Setup clip0 duration
int halfFrames = Mathf.FloorToInt(numFrames * 0.5f);
clip0.duration = halfFrames * timePerFrame;
//Setup clip1
TimelineClip clip1 = clip0.GetParentTrack().CreateClip <SceneCachePlayableAsset>();
clip1.start = clip0.start + clip0.duration;
clip1.clipIn = clip0.duration;
clip1.duration = clip0.duration;
SceneCachePlayableAsset playableAsset1 = clip1.asset as SceneCachePlayableAsset;
Assert.IsNotNull(playableAsset1);
director.SetReferenceValue(playableAsset1.GetSceneCachePlayerRef().exposedName, sceneCachePlayer);
TimelineEditorUtility.RefreshTimelineEditor(RefreshReason.ContentsAddedOrRemoved | RefreshReason.WindowNeedsRedraw | RefreshReason.ContentsModified);
yield return(null);
//Setup Limited Animation
const int NUM_FRAMES_TO_HOLD = 3;
const int OFFSET = 1;
LimitedAnimationController limitedAnimationController1 = playableAsset1.GetOverrideLimitedAnimationController();
limitedAnimationController1.Enable(NUM_FRAMES_TO_HOLD, OFFSET);
yield return(IterateAllSceneCacheFrames(director, clip0, sceneCachePlayer, (int timelineFrame) => {
EditorApplication.isPaused = true;
Assert.AreEqual(timelineFrame, sceneCachePlayer.GetFrame());
}));
yield return(IterateAllSceneCacheFrames(director, clip1, sceneCachePlayer, (int timelineFrame) => {
int shownFrame = sceneCachePlayer.GetFrame();
if (shownFrame == (scInfo.GetNumFrames() - 1)) //clamped to the end frame
{
return;
}
Assert.Zero(shownFrame % NUM_FRAMES_TO_HOLD - OFFSET);
}));
}
public void AutoUpdateFields()
{
LimitedAnimationController controller = new LimitedAnimationController(true, numFramesToHold: 3, frameOffset: 0);
AssertLimitedAnimationControllerFields(controller, 3, 0);
controller.SetFrameOffset(2);
AssertLimitedAnimationControllerFields(controller, 3, 2);
controller.SetNumFramesToHold(2);
AssertLimitedAnimationControllerFields(controller, 2, 1);
}
public void CheckResultFrames()
{
LimitedAnimationController controller = new LimitedAnimationController(true, numFramesToHold: 3, frameOffset: 0);
Assert.AreEqual(0, controller.Apply(1));
Assert.AreEqual(0, controller.Apply(2));
Assert.AreEqual(3, controller.Apply(3));
controller.SetFrameOffset(2);
Assert.AreEqual(2, controller.Apply(1));
Assert.AreEqual(2, controller.Apply(2));
Assert.AreEqual(2, controller.Apply(3));
Assert.AreEqual(2, controller.Apply(4));
Assert.AreEqual(5, controller.Apply(5));
}
public IEnumerator EnsureLimitedFramesAreLoadedToScene()
{
InitTest(true, out PlayableDirector director, out SceneCachePlayer sceneCachePlayer, out TimelineClip clip);
yield return(null);
//Setup Limited Animation
const int NUM_FRAMES_TO_HOLD = 3;
const int OFFSET = 1;
SceneCachePlayableAsset sceneCachePlayableAsset = clip.asset as SceneCachePlayableAsset;
Assert.IsNotNull(sceneCachePlayableAsset);
LimitedAnimationController limitedAnimationController = sceneCachePlayableAsset.GetOverrideLimitedAnimationController();
limitedAnimationController.Enable(NUM_FRAMES_TO_HOLD, OFFSET);
yield return(IterateAllSceneCacheFrames(director, clip, sceneCachePlayer, (int timelineFrame) => {
int shownFrame = sceneCachePlayer.GetFrame();
Assert.Zero(shownFrame % NUM_FRAMES_TO_HOLD - OFFSET);
}));
}
//----------------------------------------------------------------------------------------------------------------------
internal static bool DrawLimitedAnimationGUI(LimitedAnimationController ctrl,
Object target, SceneCachePlayer sc)
{
bool changed = false;
const string UNDO_TEXT = "SceneCache: Limited Animation";
//Limited Animation
changed |= EditorGUIDrawerUtility.DrawUndoableGUI(target, UNDO_TEXT,
guiFunc: () => (EditorGUILayout.Toggle("Limited Animation", ctrl.IsEnabled())),
updateFunc: (bool limitedAnimation) => {
ctrl.SetEnabled(limitedAnimation);
SceneCachePlayerEditorUtility.RefreshSceneCache(sc);
});
++EditorGUI.indentLevel;
using (new EditorGUI.DisabledScope(!ctrl.IsEnabled())) {
changed |= EditorGUIDrawerUtility.DrawUndoableGUI(target, UNDO_TEXT,
guiFunc: () => (
EditorGUILayout.IntField("Num Frames to Hold", ctrl.GetNumFramesToHold())
),
updateFunc: (int frames) => {
ctrl.SetNumFramesToHold(frames);
SceneCachePlayerEditorUtility.RefreshSceneCache(sc);
});
changed |= EditorGUIDrawerUtility.DrawUndoableGUI(target, UNDO_TEXT,
guiFunc: () => (
EditorGUILayout.IntField("Frame Offset", ctrl.GetFrameOffset())
),
updateFunc: (int offset) => {
ctrl.SetFrameOffset(offset);
SceneCachePlayerEditorUtility.RefreshSceneCache(sc);
});
}
--EditorGUI.indentLevel;
EditorGUILayout.Space();
return changed;
}
//----------------------------------------------------------------------------------------------------------------------
/// <inheritdoc/>
public override void DrawBackground(TimelineClip clip, ClipBackgroundRegion region) {
base.DrawBackground(clip, region);
SceneCachePlayableAsset asset = clip.asset as SceneCachePlayableAsset;
if (null == asset) {
Debug.LogError("Asset is not a SceneCachePlayableAsset: " + clip.asset);
return;
}
SceneCacheClipData clipData = asset.GetBoundClipData();
if (null == clipData)
return;
LimitedAnimationController limitedAnimationController = asset.GetOverrideLimitedAnimationController();
if (!limitedAnimationController.IsEnabled()) {
return;
}
int numFrames = limitedAnimationController.GetNumFramesToHold();
int offset = limitedAnimationController.GetFrameOffset();
GUIStyle style = new GUIStyle(GUI.skin.label) {
alignment = TextAnchor.LowerRight,
normal = {
textColor = new Color(0.3f,0.9f,0.3f),
}
};
GUIContent laContent = new GUIContent($"Limited: {numFrames}, {offset}");
Vector2 laContentSize = style.CalcSize(laContent);
Rect rect = region.position;
if (rect.width <= laContentSize.x * 2) //2: arbitrary
return;
EditorGUI.LabelField(rect, laContent, style);
}
//----------------------------------------------------------------------------------------------------------------------
private static void AssertLimitedAnimationControllerFields(LimitedAnimationController limitedAnimationController,
int numFramesToHold, int frameOffset)
{
Assert.AreEqual(numFramesToHold, limitedAnimationController.GetNumFramesToHold());
Assert.AreEqual(frameOffset, limitedAnimationController.GetFrameOffset());
}
