//----------------------------------------------------------------------------------------------------------------------
//Calculate the used image index for the passed localTime
internal int LocalTimeToImageIndex(TimelineClip clip, double localTime)
{
TimelineClipSISData timelineSISData = GetBoundTimelineClipSISData();
if (null != timelineSISData)
{
double scaledTimePerFrame = TimelineUtility.CalculateTimePerFrame(clip) * clip.timeScale;
//Try to check if this frame is "dropped", so that we should use the image in the prev frame
int playableFrameIndex = Mathf.RoundToInt((float)localTime / (float)scaledTimePerFrame);
SISPlayableFrame playableFrame = timelineSISData.GetPlayableFrame(playableFrameIndex);
while (playableFrameIndex > 0 && !playableFrame.IsUsed())
{
--playableFrameIndex;
playableFrame = timelineSISData.GetPlayableFrame(playableFrameIndex);
localTime = playableFrameIndex * scaledTimePerFrame;
}
}
double imageSequenceTime = LocalTimeToCurveTime(clip, localTime);
int count = m_imageFiles.Count;
//Can't round up, because if the time for the next frame hasn't been reached, then we should stick
int index = Mathf.FloorToInt(count * (float)imageSequenceTime);
index = Mathf.Clamp(index, 0, count - 1);
return(index);
}
//----------------------------------------------------------------------------------------------------------------------
private static SISPlayableFrame CreatePlayableFrame(TimelineClipSISData owner, int index, double timePerFrame)
{
SISPlayableFrame playableFrame = new SISPlayableFrame(owner);
playableFrame.SetIndexAndLocalTime(index, timePerFrame * index);
return(playableFrame);
}
internal TimelineClipSISData(TimelineClip owner, TimelineClipSISData other) : this(owner){
Assert.IsNotNull(m_playableFrames);
foreach (SISPlayableFrame otherFrame in other.m_playableFrames)
{
SISPlayableFrame newFrame = new SISPlayableFrame(this, otherFrame);
m_playableFrames.Add(newFrame);
}
m_frameMarkersRequested = other.m_frameMarkersRequested;
}
internal static T GetTimelineClipAsset <T>(this SISPlayableFrame playableFrame) where T : Object
{
TimelineClip timelineClip = playableFrame?.GetOwner().GetOwner();
if (null == timelineClip)
{
return(null);
}
T clipAsset = timelineClip.asset as T;
return(clipAsset);
}
internal static void SetUsed(this SISPlayableFrame playableFrame, bool used)
{
#if UNITY_EDITOR
bool prevUsed = playableFrame.IsUsed();
#endif
playableFrame.SetBoolProperty(PlayableFramePropertyID.USED, used);
#if UNITY_EDITOR
//Refresh
if (used != prevUsed)
{
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
#endif
}
//----------------------------------------------------------------------------------------------------------------------
//Calculate the used image index for the passed localTime
internal int LocalTimeToImageIndex(TimelineClip clip, double localTime)
{
SISClipData clipData = GetBoundClipData();
if (null == clipData)
{
return(0);
}
{
//drop disabled frames
double scaledTimePerFrame = TimelineUtility.CalculateTimePerFrame(clip) * clip.timeScale;
//Try to check if this frame is "dropped", so that we should use the image in the prev frame
int playableFrameIndex = Mathf.RoundToInt((float)(localTime - clip.clipIn) / (float)scaledTimePerFrame);
if (playableFrameIndex < 0)
{
return(0);
}
SISPlayableFrame playableFrame = clipData.GetPlayableFrame(playableFrameIndex);
while (playableFrameIndex > 0 && !playableFrame.IsUsed())
{
--playableFrameIndex;
playableFrame = clipData.GetPlayableFrame(playableFrameIndex);
localTime = playableFrameIndex * scaledTimePerFrame;
}
}
AnimationCurve curve = clipData.GetAnimationCurve();
double imageSequenceTime = curve.Evaluate((float)localTime);
int count = m_imageFiles.Count;
//Can't round up, because if the time for the next frame hasn't been reached, then we should stick
int index = Mathf.FloorToInt(count * (float)imageSequenceTime);
index = Mathf.Clamp(index, 0, count - 1);
return(index);
}
//----------------------------------------------------------------------------------------------------------------------
private void UpdatePlayableFramesSize(int reqPlayableFramesSize)
{
TimelineClip clipOwner = GetOwner();
Assert.IsNotNull(clipOwner);
double timePerFrame = TimelineUtility.CalculateTimePerFrame(clipOwner);
//Resize m_playableFrames
if (m_playableFrames.Count < reqPlayableFramesSize)
{
int numNewPlayableFrames = (reqPlayableFramesSize - m_playableFrames.Count);
List <SISPlayableFrame> newPlayableFrames = new List <SISPlayableFrame>(numNewPlayableFrames);
for (int i = m_playableFrames.Count; i < reqPlayableFramesSize; ++i)
{
newPlayableFrames.Add(CreatePlayableFrame(this, i, timePerFrame));
}
m_playableFrames.AddRange(newPlayableFrames);
}
if (m_playableFrames.Count > reqPlayableFramesSize)
{
int numLastPlayableFrames = m_playableFrames.Count;
for (int i = reqPlayableFramesSize; i < numLastPlayableFrames; ++i)
{
SISPlayableFrame curFrame = m_playableFrames[i];
curFrame?.Destroy();
}
m_playableFrames.RemoveRange(reqPlayableFramesSize, numLastPlayableFrames - reqPlayableFramesSize);
}
Assert.IsTrue(m_playableFrames.Count == reqPlayableFramesSize);
for (int i = 0; i < reqPlayableFramesSize; ++i)
{
SISPlayableFrame curPlayableFrame = m_playableFrames[i];
Assert.IsNotNull(curPlayableFrame);
m_playableFrames[i].SetIndexAndLocalTime(i, timePerFrame * i);
}
}
internal static bool IsLocked(this SISPlayableFrame playableFrame)
{
return(null != playableFrame && playableFrame.GetBoolProperty(PlayableFramePropertyID.LOCKED));
}
//----------------------------------------------------------------------------------------------------------------------
internal static void SetLocked(this SISPlayableFrame playableFrame, bool used)
{
playableFrame.SetBoolProperty(PlayableFramePropertyID.LOCKED, used);
}
//----------------------------------------------------------------------------------------------------------------------
internal void SetOwner(SISPlayableFrame controller)
{
m_playableFrameOwner = controller;
}
internal void Init(SISPlayableFrame controller, double initialTime)
{
m_playableFrameOwner = controller;
time = initialTime;
}
internal SISPlayableFrame(PlayableFrameClipData owner, SISPlayableFrame otherFrame)
{
m_clipDataOwner = owner;
m_boolProperties = otherFrame.m_boolProperties;
m_localTime = otherFrame.m_localTime;
}
