Unity-jump-proj
This commit is contained in:
@ -0,0 +1,89 @@
|
||||
using System;
|
||||
using JetBrains.Annotations;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Timeline;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
[CustomTrackDrawer(typeof(AnimationTrack)), UsedImplicitly]
|
||||
class AnimationTrackDrawer : TrackDrawer
|
||||
{
|
||||
static class Styles
|
||||
{
|
||||
public static readonly GUIContent AvatarMaskActiveTooltip = L10n.TextContent(string.Empty, "Enable Avatar Mask");
|
||||
public static readonly GUIContent AvatarMaskInactiveTooltip = L10n.TextContent(string.Empty, "Disable Avatar Mask");
|
||||
}
|
||||
|
||||
public override void DrawTrackHeaderButton(Rect rect, WindowState state)
|
||||
{
|
||||
var animTrack = track as AnimationTrack;
|
||||
if (animTrack == null) return;
|
||||
|
||||
var style = DirectorStyles.Instance.trackAvatarMaskButton;
|
||||
var tooltip = animTrack.applyAvatarMask ? Styles.AvatarMaskInactiveTooltip : Styles.AvatarMaskActiveTooltip;
|
||||
|
||||
using (var check = new EditorGUI.ChangeCheckScope())
|
||||
{
|
||||
var toggle = GUI.Toggle(rect, animTrack.applyAvatarMask, tooltip, style);
|
||||
if (check.changed)
|
||||
{
|
||||
animTrack.applyAvatarMask = toggle;
|
||||
if (state != null)
|
||||
state.rebuildGraph = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public override void DrawRecordingBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
|
||||
{
|
||||
base.DrawRecordingBackground(trackRect, trackAsset, visibleTime, state);
|
||||
DrawBorderOfAddedRecordingClip(trackRect, trackAsset, visibleTime, (WindowState)state);
|
||||
}
|
||||
|
||||
static void DrawBorderOfAddedRecordingClip(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
|
||||
{
|
||||
if (!state.IsArmedForRecord(trackAsset))
|
||||
return;
|
||||
|
||||
AnimationTrack animTrack = trackAsset as AnimationTrack;
|
||||
if (animTrack == null || !animTrack.inClipMode)
|
||||
return;
|
||||
|
||||
// make sure there is no clip but we can add one
|
||||
TimelineClip clip = null;
|
||||
if (trackAsset.FindRecordingClipAtTime(state.editSequence.time, out clip) || clip != null)
|
||||
return;
|
||||
|
||||
float yMax = trackRect.yMax;
|
||||
float yMin = trackRect.yMin;
|
||||
|
||||
double startGap = 0;
|
||||
double endGap = 0;
|
||||
|
||||
trackAsset.GetGapAtTime(state.editSequence.time, out startGap, out endGap);
|
||||
if (double.IsInfinity(endGap))
|
||||
endGap = visibleTime.y;
|
||||
|
||||
if (startGap > visibleTime.y || endGap < visibleTime.x)
|
||||
return;
|
||||
|
||||
|
||||
startGap = Math.Max(startGap, visibleTime.x);
|
||||
endGap = Math.Min(endGap, visibleTime.y);
|
||||
|
||||
float xMin = state.TimeToPixel(startGap);
|
||||
float xMax = state.TimeToPixel(endGap);
|
||||
|
||||
var r = Rect.MinMaxRect(xMin, yMin, xMax, yMax);
|
||||
ClipDrawer.DrawClipSelectionBorder(r, ClipBorder.Recording(), ClipBlends.kNone);
|
||||
}
|
||||
|
||||
public override bool HasCustomTrackHeaderButton()
|
||||
{
|
||||
var animTrack = track as AnimationTrack;
|
||||
if (animTrack == null) return false;
|
||||
|
||||
return animTrack != null && animTrack.avatarMask != null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: cb281723220c9964094e6c52e0ece792
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,692 @@
|
||||
using System;
|
||||
using UnityEngine.Timeline;
|
||||
using UnityEngine;
|
||||
using System.Linq;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
enum BlendKind
|
||||
{
|
||||
None,
|
||||
Ease,
|
||||
Mix
|
||||
}
|
||||
|
||||
enum BlendAngle
|
||||
{
|
||||
Descending,
|
||||
Ascending
|
||||
}
|
||||
|
||||
struct IconData
|
||||
{
|
||||
public enum Side { Left = -1, Right = 1 }
|
||||
|
||||
public Texture2D icon;
|
||||
public Color tint;
|
||||
|
||||
public float width { get { return 16; } }
|
||||
public float height { get { return 16; } }
|
||||
|
||||
public IconData(Texture2D icon)
|
||||
{
|
||||
this.icon = icon;
|
||||
tint = Color.white;
|
||||
}
|
||||
}
|
||||
|
||||
struct ClipBorder
|
||||
{
|
||||
public readonly Color color;
|
||||
public readonly float thickness;
|
||||
|
||||
ClipBorder(Color color, float thickness)
|
||||
{
|
||||
this.color = color;
|
||||
this.thickness = thickness;
|
||||
}
|
||||
|
||||
const float k_ClipSelectionBorder = 1.0f;
|
||||
const float k_ClipRecordingBorder = 2.0f;
|
||||
|
||||
public static ClipBorder Recording()
|
||||
{
|
||||
return new ClipBorder(DirectorStyles.Instance.customSkin.colorRecordingClipOutline, k_ClipRecordingBorder);
|
||||
}
|
||||
|
||||
public static ClipBorder Selection()
|
||||
{
|
||||
return new ClipBorder(Color.white, k_ClipSelectionBorder);
|
||||
}
|
||||
|
||||
public static ClipBorder Default()
|
||||
{
|
||||
return new ClipBorder(DirectorStyles.Instance.customSkin.clipBorderColor, k_ClipSelectionBorder);
|
||||
}
|
||||
}
|
||||
|
||||
struct ClipBlends
|
||||
{
|
||||
public readonly BlendKind inKind;
|
||||
public readonly Rect inRect;
|
||||
|
||||
public readonly BlendKind outKind;
|
||||
public readonly Rect outRect;
|
||||
|
||||
public ClipBlends(BlendKind inKind, Rect inRect, BlendKind outKind, Rect outRect)
|
||||
{
|
||||
this.inKind = inKind;
|
||||
this.inRect = inRect;
|
||||
this.outKind = outKind;
|
||||
this.outRect = outRect;
|
||||
}
|
||||
|
||||
public static readonly ClipBlends kNone = new ClipBlends(BlendKind.None, Rect.zero, BlendKind.None, Rect.zero);
|
||||
}
|
||||
|
||||
struct ClipDrawData
|
||||
{
|
||||
public TimelineClip clip; // clip being drawn
|
||||
public Rect targetRect; // rectangle to draw to
|
||||
public Rect unclippedRect; // the clip's unclipped rect
|
||||
public Rect clippedRect; // the clip's clipped rect to the visible time area
|
||||
public Rect clipCenterSection; // clip center section
|
||||
public string title; // clip title
|
||||
public bool selected; // is the clip selected
|
||||
public bool inlineCurvesSelected; // is the inline curve of the clip selected
|
||||
public double localVisibleStartTime;
|
||||
public double localVisibleEndTime;
|
||||
public IconData[] leftIcons;
|
||||
public IconData[] rightIcons;
|
||||
public TimelineClip previousClip;
|
||||
public bool previousClipSelected;
|
||||
public bool supportsLooping;
|
||||
public int minLoopIndex;
|
||||
public List<Rect> loopRects;
|
||||
public ClipBlends clipBlends;
|
||||
public ClipDrawOptions ClipDrawOptions;
|
||||
public ClipEditor clipEditor;
|
||||
}
|
||||
|
||||
static class ClipDrawer
|
||||
{
|
||||
public static class Styles
|
||||
{
|
||||
public static readonly Texture2D iconWarn = EditorGUIUtility.LoadIconRequired("console.warnicon.inactive.sml");
|
||||
public static readonly string HoldText = L10n.Tr("HOLD");
|
||||
public static readonly Texture2D s_IconNoRecord = EditorGUIUtility.LoadIcon("console.erroricon.sml");
|
||||
public static readonly GUIContent s_ClipNotRecorable = L10n.TextContent("", "This clip is not recordable");
|
||||
public static readonly GUIContent s_ClipNoRecordInBlend = L10n.TextContent("", "Recording in blends in prohibited");
|
||||
}
|
||||
|
||||
const float k_ClipSwatchLineThickness = 4.0f;
|
||||
const float k_MinClipWidth = 7.0f;
|
||||
const float k_ClipInOutMinWidth = 15.0f;
|
||||
const float k_ClipLoopsMinWidth = 20.0f;
|
||||
const float k_ClipLabelPadding = 6.0f;
|
||||
const float k_ClipLabelMinWidth = 10.0f;
|
||||
const float k_IconsPadding = 1.0f;
|
||||
const float k_ClipInlineWidth = 1.0f;
|
||||
|
||||
static readonly GUIContent s_TitleContent = new GUIContent();
|
||||
static readonly IconData[] k_ClipErrorIcons = { new IconData { icon = Styles.iconWarn, tint = DirectorStyles.kClipErrorColor } };
|
||||
static readonly Dictionary<int, string> s_LoopStringCache = new Dictionary<int, string>(100);
|
||||
|
||||
// caches the loopstring to avoid allocation from string concats
|
||||
static string GetLoopString(int loopIndex)
|
||||
{
|
||||
string loopString = null;
|
||||
if (!s_LoopStringCache.TryGetValue(loopIndex, out loopString))
|
||||
{
|
||||
loopString = "L" + loopIndex;
|
||||
s_LoopStringCache[loopIndex] = loopString;
|
||||
}
|
||||
return loopString;
|
||||
}
|
||||
|
||||
static void DrawLoops(ClipDrawData drawData)
|
||||
{
|
||||
if (drawData.loopRects == null || drawData.loopRects.Count == 0)
|
||||
return;
|
||||
|
||||
var oldColor = GUI.color;
|
||||
|
||||
int loopIndex = drawData.minLoopIndex;
|
||||
for (int l = 0; l < drawData.loopRects.Count; l++)
|
||||
{
|
||||
Rect theRect = drawData.loopRects[l];
|
||||
theRect.x -= drawData.unclippedRect.x;
|
||||
theRect.x += 1;
|
||||
theRect.width -= 2.0f;
|
||||
theRect.y = 5.0f;
|
||||
theRect.height -= 4.0f;
|
||||
theRect.xMin -= 4f;
|
||||
|
||||
if (theRect.width >= 5f)
|
||||
{
|
||||
using (new GUIViewportScope(drawData.clipCenterSection))
|
||||
{
|
||||
GUI.color = new Color(0.0f, 0.0f, 0.0f, 0.2f);
|
||||
GUI.Label(theRect, GUIContent.none, DirectorStyles.Instance.displayBackground);
|
||||
|
||||
if (theRect.width > 36.0f)
|
||||
{
|
||||
var style = DirectorStyles.Instance.fontClipLoop;
|
||||
GUI.color = new Color(0.0f, 0.0f, 0.0f, 0.3f);
|
||||
var loopContent = new GUIContent(drawData.supportsLooping ? GetLoopString(loopIndex) : Styles.HoldText);
|
||||
GUI.Label(theRect, loopContent, style);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
loopIndex++;
|
||||
|
||||
if (!drawData.supportsLooping)
|
||||
break;
|
||||
}
|
||||
|
||||
GUI.color = oldColor;
|
||||
}
|
||||
|
||||
static void DrawClipBorder(ClipDrawData drawData)
|
||||
{
|
||||
var animTrack = drawData.clip.GetParentTrack() as AnimationTrack;
|
||||
var selectionBorder = ClipBorder.Selection();
|
||||
|
||||
if (TimelineWindow.instance.state.recording && animTrack == null && drawData.clip.GetParentTrack().IsRecordingToClip(drawData.clip))
|
||||
{
|
||||
DrawClipSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends);
|
||||
return;
|
||||
}
|
||||
|
||||
DrawClipDefaultBorder(drawData.clipCenterSection, ClipBorder.Default(), drawData.clipBlends);
|
||||
|
||||
if (drawData.selected)
|
||||
DrawClipSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends);
|
||||
|
||||
if (drawData.previousClip != null && drawData.previousClipSelected)
|
||||
{
|
||||
bool shouldDrawLeftLine = Math.Abs(drawData.previousClip.start - drawData.clip.start) < double.Epsilon;
|
||||
DrawClipBlendSelectionBorder(drawData.clipCenterSection, selectionBorder, drawData.clipBlends, shouldDrawLeftLine);
|
||||
}
|
||||
}
|
||||
|
||||
public static void DrawClipSelectionBorder(Rect clipRect, ClipBorder border, ClipBlends blends)
|
||||
{
|
||||
var thickness = border.thickness;
|
||||
var color = border.color;
|
||||
var min = clipRect.min;
|
||||
var max = clipRect.max;
|
||||
|
||||
//Left line
|
||||
if (blends.inKind == BlendKind.None)
|
||||
EditorGUI.DrawRect(new Rect(min.x, min.y, thickness, max.y - min.y), color);
|
||||
else
|
||||
DrawBlendLine(blends.inRect, blends.inKind == BlendKind.Mix ? BlendAngle.Descending : BlendAngle.Ascending, thickness, color);
|
||||
|
||||
//Right line
|
||||
if (blends.outKind == BlendKind.None)
|
||||
EditorGUI.DrawRect(new Rect(max.x - thickness, min.y, thickness, max.y - min.y), color);
|
||||
else
|
||||
DrawBlendLine(blends.outRect, BlendAngle.Descending, thickness, color);
|
||||
|
||||
//Top line
|
||||
var xTop1 = blends.inKind == BlendKind.Mix ? blends.inRect.xMin : min.x;
|
||||
var xTop2 = max.x;
|
||||
EditorGUI.DrawRect(new Rect(xTop1, min.y, xTop2 - xTop1, thickness), color);
|
||||
|
||||
//Bottom line
|
||||
var xBottom1 = blends.inKind == BlendKind.Ease ? blends.inRect.xMin : min.x;
|
||||
var xBottom2 = blends.outKind == BlendKind.None ? max.x : blends.outRect.xMax;
|
||||
EditorGUI.DrawRect(new Rect(xBottom1, max.y - thickness, xBottom2 - xBottom1, thickness), color);
|
||||
}
|
||||
|
||||
static Vector3[] s_BlendLines = new Vector3[4];
|
||||
static void DrawBlendLine(Rect rect, BlendAngle blendAngle, float width, Color color)
|
||||
{
|
||||
var halfWidth = width / 2.0f;
|
||||
Vector2 p0, p1;
|
||||
var inverse = 1.0f;
|
||||
if (blendAngle == BlendAngle.Descending)
|
||||
{
|
||||
p0 = rect.min;
|
||||
p1 = rect.max;
|
||||
}
|
||||
else
|
||||
{
|
||||
p0 = new Vector2(rect.xMax, rect.yMin);
|
||||
p1 = new Vector2(rect.xMin, rect.yMax);
|
||||
inverse = -1.0f;
|
||||
}
|
||||
s_BlendLines[0] = new Vector3(p0.x - halfWidth, p0.y + halfWidth * inverse);
|
||||
s_BlendLines[1] = new Vector3(p1.x - halfWidth, p1.y + halfWidth * inverse);
|
||||
s_BlendLines[2] = new Vector3(p1.x + halfWidth, p1.y - halfWidth * inverse);
|
||||
s_BlendLines[3] = new Vector3(p0.x + halfWidth, p0.y - halfWidth * inverse);
|
||||
Graphics.DrawPolygonAA(color, s_BlendLines);
|
||||
}
|
||||
|
||||
static void DrawClipBlendSelectionBorder(Rect clipRect, ClipBorder border, ClipBlends blends, bool shouldLeftLine = false)
|
||||
{
|
||||
var color = border.color;
|
||||
var thickness = border.thickness;
|
||||
if (blends.inKind == BlendKind.Mix)
|
||||
{
|
||||
DrawBlendLine(blends.inRect, BlendAngle.Descending, thickness, color);
|
||||
var xBottom1 = blends.inRect.xMin;
|
||||
var xBottom2 = blends.inRect.xMax;
|
||||
EditorGUI.DrawRect(new Rect(xBottom1, clipRect.max.y - thickness, xBottom2 - xBottom1, thickness), color);
|
||||
if (shouldLeftLine)
|
||||
EditorGUI.DrawRect(new Rect(xBottom1, clipRect.min.y, thickness, clipRect.max.y - clipRect.min.y), color);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawClipDefaultBorder(Rect clipRect, ClipBorder border, ClipBlends blends)
|
||||
{
|
||||
var color = border.color;
|
||||
var thickness = border.thickness;
|
||||
|
||||
// Draw vertical lines at the edges of the clip
|
||||
EditorGUI.DrawRect(new Rect(clipRect.xMin, clipRect.y, thickness, clipRect.height), color); //left
|
||||
//only draw the right one when no out mix blend
|
||||
if (blends.outKind != BlendKind.Mix)
|
||||
EditorGUI.DrawRect(new Rect(clipRect.xMax - thickness, clipRect.y, thickness, clipRect.height), color); //right
|
||||
//draw a vertical line for the previous clip
|
||||
if (blends.inKind == BlendKind.Mix)
|
||||
EditorGUI.DrawRect(new Rect(blends.inRect.xMin, blends.inRect.y, thickness, blends.inRect.height), color); //left
|
||||
|
||||
//Draw blend line
|
||||
if (blends.inKind == BlendKind.Mix)
|
||||
DrawBlendLine(blends.inRect, BlendAngle.Descending, thickness, color);
|
||||
}
|
||||
|
||||
static void DrawClipTimescale(Rect targetRect, Rect clippedRect, double timeScale)
|
||||
{
|
||||
if (timeScale != 1.0)
|
||||
{
|
||||
const float xOffset = 4.0f;
|
||||
const float yOffset = 6.0f;
|
||||
var segmentLength = timeScale > 1.0f ? 5.0f : 15.0f;
|
||||
|
||||
// clamp to the visible region to reduce the line count (case 1213189), but adject the start segment to match the visuals of drawing targetRect
|
||||
var startX = clippedRect.min.x - ((clippedRect.min.x - targetRect.min.x) % (segmentLength * 2));
|
||||
var endX = clippedRect.max.x;
|
||||
|
||||
var start = new Vector3(startX + xOffset, targetRect.min.y + yOffset, 0.0f);
|
||||
var end = new Vector3(endX - xOffset, targetRect.min.y + yOffset, 0.0f);
|
||||
|
||||
Graphics.DrawDottedLine(start, end, segmentLength, DirectorStyles.Instance.customSkin.colorClipFont);
|
||||
Graphics.DrawDottedLine(start + new Vector3(0.0f, 1.0f, 0.0f), end + new Vector3(0.0f, 1.0f, 0.0f), segmentLength, DirectorStyles.Instance.customSkin.colorClipFont);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawClipInOut(Rect targetRect, TimelineClip clip)
|
||||
{
|
||||
var assetDuration = TimelineHelpers.GetClipAssetEndTime(clip);
|
||||
|
||||
bool drawClipOut = assetDuration < double.MaxValue &&
|
||||
assetDuration - clip.end > TimeUtility.kTimeEpsilon;
|
||||
|
||||
bool drawClipIn = clip.clipIn > 0.0;
|
||||
|
||||
if (!drawClipIn && !drawClipOut)
|
||||
return;
|
||||
|
||||
var rect = targetRect;
|
||||
|
||||
if (drawClipOut)
|
||||
{
|
||||
var icon = DirectorStyles.Instance.clipOut;
|
||||
var iconRect = new Rect(rect.xMax - icon.fixedWidth - 2.0f,
|
||||
rect.yMin + (rect.height - icon.fixedHeight) * 0.5f,
|
||||
icon.fixedWidth, icon.fixedHeight);
|
||||
|
||||
GUI.Label(iconRect, GUIContent.none, icon);
|
||||
}
|
||||
|
||||
if (drawClipIn)
|
||||
{
|
||||
var icon = DirectorStyles.Instance.clipIn;
|
||||
var iconRect = new Rect(2.0f + rect.xMin,
|
||||
rect.yMin + (rect.height - icon.fixedHeight) * 0.5f,
|
||||
icon.fixedWidth, icon.fixedHeight);
|
||||
|
||||
GUI.Label(iconRect, GUIContent.none, icon);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawClipLabel(ClipDrawData data, Rect availableRect, Color color)
|
||||
{
|
||||
var errorText = data.ClipDrawOptions.errorText;
|
||||
var hasError = !string.IsNullOrEmpty(errorText);
|
||||
var textColor = hasError ? DirectorStyles.kClipErrorColor : color;
|
||||
var tooltip = hasError ? errorText : data.ClipDrawOptions.tooltip;
|
||||
var displayTitle = data.ClipDrawOptions.displayClipName;
|
||||
|
||||
if (hasError)
|
||||
DrawClipLabel(data.title, availableRect, textColor, k_ClipErrorIcons, null, tooltip, displayTitle);
|
||||
else
|
||||
DrawClipLabel(data.title, availableRect, textColor, data.leftIcons, data.rightIcons, tooltip, displayTitle);
|
||||
}
|
||||
|
||||
static void DrawClipLabel(string title, Rect availableRect, Color color, string errorText = "", bool displayTitle = true)
|
||||
{
|
||||
var hasError = !string.IsNullOrEmpty(errorText);
|
||||
var textColor = hasError ? DirectorStyles.kClipErrorColor : color;
|
||||
|
||||
if (hasError)
|
||||
DrawClipLabel(title, availableRect, textColor, k_ClipErrorIcons, null, errorText, displayTitle);
|
||||
else
|
||||
DrawClipLabel(title, availableRect, textColor, null, null, errorText, displayTitle);
|
||||
}
|
||||
|
||||
static void DrawClipLabel(string title, Rect availableRect, Color textColor, IconData[] leftIcons, IconData[] rightIcons, string tooltipMessage = "", bool displayTitle = true)
|
||||
{
|
||||
var neededIconWidthLeft = 0.0f;
|
||||
var neededIconWidthRight = 0.0f;
|
||||
|
||||
if (leftIcons != null)
|
||||
for (int i = 0, n = leftIcons.Length; i < n; ++i)
|
||||
neededIconWidthLeft += leftIcons[i].width + k_IconsPadding;
|
||||
|
||||
if (rightIcons != null)
|
||||
for (int i = 0, n = rightIcons.Length; i < n; ++i)
|
||||
neededIconWidthRight += rightIcons[i].width + k_IconsPadding;
|
||||
|
||||
var neededIconWidth = Mathf.Max(neededIconWidthLeft, neededIconWidthRight);
|
||||
float iconPosX = availableRect.center.x;
|
||||
float halfTextWidth = 0;
|
||||
if (displayTitle)
|
||||
{
|
||||
s_TitleContent.text = title;
|
||||
var neededTextWidth = DirectorStyles.Instance.fontClip.CalcSize(s_TitleContent).x;
|
||||
if (neededTextWidth > availableRect.width)
|
||||
s_TitleContent.text = DirectorStyles.Elipsify(title, availableRect.width, neededTextWidth);
|
||||
halfTextWidth = neededTextWidth / 2.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
// text is set explicitly to an empty string to avoid drawing the default text on mac.
|
||||
s_TitleContent.text = String.Empty;
|
||||
iconPosX -= neededIconWidth / 2.0f;
|
||||
}
|
||||
|
||||
// Atomic operation: We either show all icons or no icons at all
|
||||
if (halfTextWidth + neededIconWidth < availableRect.width / 2.0f)
|
||||
{
|
||||
if (leftIcons != null)
|
||||
DrawClipIcons(leftIcons, IconData.Side.Left, iconPosX - halfTextWidth, availableRect.center.y);
|
||||
|
||||
if (rightIcons != null)
|
||||
DrawClipIcons(rightIcons, IconData.Side.Right, iconPosX + halfTextWidth, availableRect.center.y);
|
||||
}
|
||||
|
||||
//draw label even if empty to display tooltip
|
||||
s_TitleContent.tooltip = tooltipMessage;
|
||||
DrawClipName(availableRect, s_TitleContent, textColor);
|
||||
}
|
||||
|
||||
static void DrawClipIcons(IconData[] icons, IconData.Side side, float positionX, float positionY)
|
||||
{
|
||||
float offset = k_IconsPadding;
|
||||
foreach (var iconData in icons)
|
||||
{
|
||||
offset += (iconData.width / 2.0f + k_IconsPadding);
|
||||
|
||||
var iconRect =
|
||||
new Rect(0.0f, 0.0f, iconData.width, iconData.height)
|
||||
{
|
||||
center = new Vector2(positionX + offset * (int)side, positionY)
|
||||
};
|
||||
|
||||
DrawIcon(iconRect, iconData.tint, iconData.icon);
|
||||
|
||||
offset += iconData.width / 2.0f;
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawClipName(Rect rect, GUIContent content, Color textColor)
|
||||
{
|
||||
Graphics.ShadowLabel(rect, content, DirectorStyles.Instance.fontClip, textColor, Color.black);
|
||||
}
|
||||
|
||||
static void DrawIcon(Rect imageRect, Color color, Texture2D icon)
|
||||
{
|
||||
GUI.DrawTexture(imageRect, icon, ScaleMode.ScaleAndCrop, true, 0, color, 0, 0);
|
||||
}
|
||||
|
||||
static void DrawClipBackground(Rect clipCenterSection, bool selected)
|
||||
{
|
||||
if (Event.current.type != EventType.Repaint)
|
||||
return;
|
||||
|
||||
var color = selected ? DirectorStyles.Instance.customSkin.clipSelectedBckg : DirectorStyles.Instance.customSkin.clipBckg;
|
||||
EditorGUI.DrawRect(clipCenterSection, color);
|
||||
}
|
||||
|
||||
static Vector3[] s_BlendVertices = new Vector3[3];
|
||||
static void DrawClipBlends(ClipBlends blends, Color inColor, Color outColor, Color backgroundColor)
|
||||
{
|
||||
switch (blends.inKind)
|
||||
{
|
||||
case BlendKind.Ease:
|
||||
// 2
|
||||
// / |
|
||||
// / |
|
||||
// 0---1
|
||||
EditorGUI.DrawRect(blends.inRect, backgroundColor);
|
||||
s_BlendVertices[0] = new Vector3(blends.inRect.xMin, blends.inRect.yMax);
|
||||
s_BlendVertices[1] = new Vector3(blends.inRect.xMax, blends.inRect.yMax);
|
||||
s_BlendVertices[2] = new Vector3(blends.inRect.xMax, blends.inRect.yMin);
|
||||
Graphics.DrawPolygonAA(inColor, s_BlendVertices);
|
||||
break;
|
||||
case BlendKind.Mix:
|
||||
// 0---2
|
||||
// \ |
|
||||
// \ |
|
||||
// 1
|
||||
s_BlendVertices[0] = new Vector3(blends.inRect.xMin, blends.inRect.yMin);
|
||||
s_BlendVertices[1] = new Vector3(blends.inRect.xMax, blends.inRect.yMax);
|
||||
s_BlendVertices[2] = new Vector3(blends.inRect.xMax, blends.inRect.yMin);
|
||||
Graphics.DrawPolygonAA(inColor, s_BlendVertices);
|
||||
break;
|
||||
}
|
||||
|
||||
if (blends.outKind != BlendKind.None)
|
||||
{
|
||||
if (blends.outKind == BlendKind.Ease)
|
||||
EditorGUI.DrawRect(blends.outRect, backgroundColor);
|
||||
// 0
|
||||
// | \
|
||||
// | \
|
||||
// 1---2
|
||||
s_BlendVertices[0] = new Vector3(blends.outRect.xMin, blends.outRect.yMin);
|
||||
s_BlendVertices[1] = new Vector3(blends.outRect.xMin, blends.outRect.yMax);
|
||||
s_BlendVertices[2] = new Vector3(blends.outRect.xMax, blends.outRect.yMax);
|
||||
Graphics.DrawPolygonAA(outColor, s_BlendVertices);
|
||||
}
|
||||
}
|
||||
|
||||
static void DrawClipSwatch(Rect targetRect, Color swatchColor)
|
||||
{
|
||||
// Draw Colored Line at the bottom.
|
||||
var colorRect = targetRect;
|
||||
colorRect.yMin = colorRect.yMax - k_ClipSwatchLineThickness;
|
||||
EditorGUI.DrawRect(colorRect, swatchColor);
|
||||
}
|
||||
|
||||
public static void DrawSimpleClip(TimelineClip clip, Rect targetRect, ClipBorder border, Color overlay, ClipDrawOptions drawOptions)
|
||||
{
|
||||
GUI.BeginClip(targetRect);
|
||||
var clipRect = new Rect(0.0f, 0.0f, targetRect.width, targetRect.height);
|
||||
|
||||
var orgColor = GUI.color;
|
||||
GUI.color = overlay;
|
||||
|
||||
DrawClipBackground(clipRect, false);
|
||||
GUI.color = orgColor;
|
||||
|
||||
if (clipRect.width <= k_MinClipWidth)
|
||||
{
|
||||
clipRect.width = k_MinClipWidth;
|
||||
}
|
||||
|
||||
DrawClipSwatch(targetRect, drawOptions.highlightColor * overlay);
|
||||
|
||||
if (targetRect.width >= k_ClipInOutMinWidth)
|
||||
DrawClipInOut(clipRect, clip);
|
||||
|
||||
var textRect = clipRect;
|
||||
|
||||
textRect.xMin += k_ClipLabelPadding;
|
||||
textRect.xMax -= k_ClipLabelPadding;
|
||||
|
||||
if (textRect.width > k_ClipLabelMinWidth)
|
||||
DrawClipLabel(clip.displayName, textRect, Color.white, drawOptions.errorText, drawOptions.displayClipName);
|
||||
|
||||
DrawClipSelectionBorder(clipRect, border, ClipBlends.kNone);
|
||||
|
||||
GUI.EndClip();
|
||||
}
|
||||
|
||||
public static void DrawDefaultClip(ClipDrawData drawData)
|
||||
{
|
||||
var customSkin = DirectorStyles.Instance.customSkin;
|
||||
var blendInColor = drawData.selected ? customSkin.clipBlendInSelected : customSkin.clipBlendIn;
|
||||
var blendOutColor = drawData.selected ? customSkin.clipBlendOutSelected : customSkin.clipBlendOut;
|
||||
var easeBackgroundColor = customSkin.clipEaseBckgColor;
|
||||
|
||||
DrawClipBlends(drawData.clipBlends, blendInColor, blendOutColor, easeBackgroundColor);
|
||||
DrawClipBackground(drawData.clipCenterSection, drawData.selected);
|
||||
|
||||
if (drawData.targetRect.width > k_MinClipWidth)
|
||||
{
|
||||
DrawClipEditorBackground(drawData);
|
||||
}
|
||||
else
|
||||
{
|
||||
drawData.targetRect.width = k_MinClipWidth;
|
||||
drawData.clipCenterSection.width = k_MinClipWidth;
|
||||
}
|
||||
|
||||
if (!drawData.ClipDrawOptions.hideScaleIndicator)
|
||||
DrawClipTimescale(drawData.targetRect, drawData.clippedRect, drawData.clip.timeScale);
|
||||
|
||||
if (drawData.targetRect.width >= k_ClipInOutMinWidth)
|
||||
DrawClipInOut(drawData.targetRect, drawData.clip);
|
||||
|
||||
var labelRect = drawData.clipCenterSection;
|
||||
|
||||
if (drawData.targetRect.width >= k_ClipLoopsMinWidth)
|
||||
{
|
||||
bool selected = drawData.selected || drawData.inlineCurvesSelected;
|
||||
|
||||
if (selected)
|
||||
{
|
||||
if (drawData.loopRects != null && drawData.loopRects.Any())
|
||||
{
|
||||
DrawLoops(drawData);
|
||||
|
||||
var l = drawData.loopRects[0];
|
||||
labelRect.xMax = Math.Min(labelRect.xMax, l.x - drawData.unclippedRect.x);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
labelRect.xMin += k_ClipLabelPadding;
|
||||
labelRect.xMax -= k_ClipLabelPadding;
|
||||
|
||||
if (labelRect.width > k_ClipLabelMinWidth)
|
||||
{
|
||||
DrawClipLabel(drawData, labelRect, Color.white);
|
||||
}
|
||||
|
||||
DrawClipSwatch(drawData.targetRect, drawData.ClipDrawOptions.highlightColor);
|
||||
DrawClipBorder(drawData);
|
||||
}
|
||||
|
||||
static void DrawClipEditorBackground(ClipDrawData drawData)
|
||||
{
|
||||
var isRepaint = (Event.current.type == EventType.Repaint);
|
||||
if (isRepaint && drawData.clipEditor != null)
|
||||
{
|
||||
var customBodyRect = drawData.clippedRect;
|
||||
customBodyRect.yMin += k_ClipInlineWidth;
|
||||
customBodyRect.yMax -= k_ClipSwatchLineThickness;
|
||||
var region = new ClipBackgroundRegion(customBodyRect, drawData.localVisibleStartTime, drawData.localVisibleEndTime);
|
||||
try
|
||||
{
|
||||
drawData.clipEditor.DrawBackground(drawData.clip, region);
|
||||
}
|
||||
catch (Exception e)
|
||||
{
|
||||
Debug.LogException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void DrawAnimationRecordBorder(ClipDrawData drawData)
|
||||
{
|
||||
if (!drawData.clip.GetParentTrack().IsRecordingToClip(drawData.clip))
|
||||
return;
|
||||
|
||||
var time = new DiscreteTime(TimelineWindow.instance.state.editSequence.time);
|
||||
var start = new DiscreteTime(drawData.clip.start + drawData.clip.mixInDuration);
|
||||
var end = new DiscreteTime(drawData.clip.end - drawData.clip.mixOutDuration);
|
||||
|
||||
if (time < start || time >= end)
|
||||
return;
|
||||
|
||||
DrawClipSelectionBorder(drawData.clipCenterSection, ClipBorder.Recording(), ClipBlends.kNone);
|
||||
}
|
||||
|
||||
public static void DrawRecordProhibited(ClipDrawData drawData)
|
||||
{
|
||||
DrawRecordInvalidClip(drawData);
|
||||
DrawRecordOnBlend(drawData);
|
||||
}
|
||||
|
||||
public static void DrawRecordOnBlend(ClipDrawData drawData)
|
||||
{
|
||||
double time = TimelineWindow.instance.state.editSequence.time;
|
||||
if (time >= drawData.clip.start && time < drawData.clip.start + drawData.clip.mixInDuration)
|
||||
{
|
||||
Rect r = Rect.MinMaxRect(drawData.clippedRect.xMin, drawData.clippedRect.yMin, drawData.clipCenterSection.xMin, drawData.clippedRect.yMax);
|
||||
DrawInvalidRecordIcon(r, Styles.s_ClipNoRecordInBlend);
|
||||
}
|
||||
|
||||
if (time <= drawData.clip.end && time > drawData.clip.end - drawData.clip.mixOutDuration)
|
||||
{
|
||||
Rect r = Rect.MinMaxRect(drawData.clipCenterSection.xMax, drawData.clippedRect.yMin, drawData.clippedRect.xMax, drawData.clippedRect.yMax);
|
||||
DrawInvalidRecordIcon(r, Styles.s_ClipNoRecordInBlend);
|
||||
}
|
||||
}
|
||||
|
||||
public static void DrawRecordInvalidClip(ClipDrawData drawData)
|
||||
{
|
||||
if (drawData.clip.recordable)
|
||||
return;
|
||||
|
||||
double time = TimelineWindow.instance.state.editSequence.time;
|
||||
if (time < drawData.clip.start + drawData.clip.mixInDuration || time > drawData.clip.end - drawData.clip.mixOutDuration)
|
||||
return;
|
||||
|
||||
DrawInvalidRecordIcon(drawData.clipCenterSection, Styles.s_ClipNotRecorable);
|
||||
}
|
||||
|
||||
public static void DrawInvalidRecordIcon(Rect rect, GUIContent helpText)
|
||||
{
|
||||
EditorGUI.DrawRect(rect, new Color(0, 0, 0, 0.30f));
|
||||
|
||||
var icon = Styles.s_IconNoRecord;
|
||||
if (rect.width < icon.width || rect.height < icon.height)
|
||||
return;
|
||||
|
||||
float x = rect.x + (rect.width - icon.width) * 0.5f;
|
||||
float y = rect.y + (rect.height - icon.height) * 0.5f;
|
||||
Rect r = new Rect(x, y, icon.width, icon.height);
|
||||
GUI.Label(r, helpText);
|
||||
GUI.DrawTexture(r, icon, ScaleMode.ScaleAndCrop, true, 0, Color.white, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 63118a0c9ee42ac46b7f30e793177a76
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,87 @@
|
||||
using UnityEngine;
|
||||
using UnityEngine.Timeline;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
class InfiniteTrackDrawer : TrackDrawer
|
||||
{
|
||||
readonly IPropertyKeyDataSource m_DataSource;
|
||||
Rect m_TrackRect;
|
||||
|
||||
public InfiniteTrackDrawer(IPropertyKeyDataSource dataSource)
|
||||
{
|
||||
m_DataSource = dataSource;
|
||||
}
|
||||
|
||||
public bool CanDraw(TrackAsset track, WindowState state)
|
||||
{
|
||||
var keys = m_DataSource.GetKeys();
|
||||
var isTrackEmpty = track.clips.Length == 0;
|
||||
|
||||
return keys != null || (state.IsArmedForRecord(track) && isTrackEmpty);
|
||||
}
|
||||
|
||||
static void DrawRecordBackground(Rect trackRect)
|
||||
{
|
||||
var styles = DirectorStyles.Instance;
|
||||
|
||||
EditorGUI.DrawRect(trackRect, styles.customSkin.colorInfiniteTrackBackgroundRecording);
|
||||
|
||||
Graphics.ShadowLabel(trackRect,
|
||||
DirectorStyles.Elipsify(DirectorStyles.recordingLabel.text, trackRect, styles.fontClip),
|
||||
styles.fontClip, Color.white, Color.black);
|
||||
}
|
||||
|
||||
public override bool DrawTrack(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
|
||||
{
|
||||
m_TrackRect = trackRect;
|
||||
|
||||
if (!CanDraw(trackAsset, state))
|
||||
return true;
|
||||
|
||||
if (state.recording && state.IsArmedForRecord(trackAsset))
|
||||
DrawRecordBackground(trackRect);
|
||||
|
||||
if (m_DataSource.GetKeys() != null && m_DataSource.GetKeys().Length > 0 || state.recording)
|
||||
GUI.Box(trackRect, GUIContent.none, DirectorStyles.Instance.infiniteTrack);
|
||||
|
||||
var shadowRect = trackRect;
|
||||
shadowRect.yMin = shadowRect.yMax;
|
||||
shadowRect.height = 15.0f;
|
||||
if (Event.current.type == EventType.Repaint)
|
||||
DirectorStyles.Instance.bottomShadow.Draw(shadowRect, false, false, false, false);
|
||||
|
||||
var keys = m_DataSource.GetKeys();
|
||||
if (keys != null && keys.Length > 0)
|
||||
{
|
||||
foreach (var k in keys)
|
||||
DrawKeyFrame(k, state);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void DrawKeyFrame(float key, WindowState state)
|
||||
{
|
||||
var x = state.TimeToPixel(key);
|
||||
var bounds = new Rect(x, m_TrackRect.yMin + 3.0f, 1.0f, m_TrackRect.height - 6.0f);
|
||||
|
||||
if (!m_TrackRect.Overlaps(bounds))
|
||||
return;
|
||||
|
||||
var iconWidth = DirectorStyles.Instance.keyframe.fixedWidth;
|
||||
var iconHeight = DirectorStyles.Instance.keyframe.fixedHeight;
|
||||
|
||||
var keyframeRect = bounds;
|
||||
keyframeRect.width = iconWidth;
|
||||
keyframeRect.height = iconHeight;
|
||||
keyframeRect.xMin -= iconWidth / 2.0f;
|
||||
keyframeRect.yMin = m_TrackRect.yMin + ((m_TrackRect.height - iconHeight) / 2.0f);
|
||||
|
||||
// case 890650 : Make sure to use GUI.Label and not GUI.Box since the number of key frames can vary while dragging keys in the inline curves causing hotControls to be desynchronized
|
||||
GUI.Label(keyframeRect, GUIContent.none, DirectorStyles.Instance.keyframe);
|
||||
|
||||
EditorGUI.DrawRect(bounds, DirectorStyles.Instance.customSkin.colorInfiniteClipLine);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 5ea6a8a826704f743b3b0ce3e9d3c9a9
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 16388ae022a89264b84107f0c1b44680
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,63 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Timeline;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
class ClipsLayer : ItemsLayer<TimelineClipGUI>
|
||||
{
|
||||
static readonly GUIStyle k_ConnectorIcon = DirectorStyles.Instance.connector;
|
||||
|
||||
public ClipsLayer(Layer layerOrder, IRowGUI parent) : base(layerOrder)
|
||||
{
|
||||
var track = parent.asset;
|
||||
track.SortClips();
|
||||
TimelineClipGUI previousClipGUI = null;
|
||||
|
||||
foreach (var clip in track.clips)
|
||||
{
|
||||
var oldClipGUI = ItemToItemGui.GetGuiForClip(clip);
|
||||
var isInvalid = oldClipGUI != null && oldClipGUI.isInvalid; // HACK Make sure to carry invalidy state when refereshing the cache.
|
||||
|
||||
var currentClipGUI = new TimelineClipGUI(clip, parent, this) { isInvalid = isInvalid };
|
||||
if (previousClipGUI != null) previousClipGUI.nextClip = currentClipGUI;
|
||||
currentClipGUI.previousClip = previousClipGUI;
|
||||
AddItem(currentClipGUI);
|
||||
previousClipGUI = currentClipGUI;
|
||||
}
|
||||
|
||||
//adjust zOrder based on current clip selection
|
||||
foreach (var clipGUI in items)
|
||||
{
|
||||
if (clipGUI.IsSelected())
|
||||
clipGUI.MoveToTop();
|
||||
}
|
||||
}
|
||||
|
||||
public override void Draw(Rect rect, WindowState state)
|
||||
{
|
||||
base.Draw(rect, state); //draw clips
|
||||
DrawConnector(items);
|
||||
}
|
||||
|
||||
static void DrawConnector(List<TimelineClipGUI> clips)
|
||||
{
|
||||
if (Event.current.type != EventType.Repaint)
|
||||
return;
|
||||
|
||||
foreach (var clip in clips)
|
||||
{
|
||||
if (clip.previousClip != null && clip.visible && clip.treeViewRect.width > 14 &&
|
||||
(DiscreteTime)clip.start == (DiscreteTime)clip.previousClip.end)
|
||||
{
|
||||
// draw little connector widget
|
||||
var localRect = clip.treeViewRect;
|
||||
localRect.x -= Mathf.Floor(k_ConnectorIcon.fixedWidth / 2.0f);
|
||||
localRect.width = k_ConnectorIcon.fixedWidth;
|
||||
localRect.height = k_ConnectorIcon.fixedHeight;
|
||||
GUI.Label(localRect, GUIContent.none, k_ConnectorIcon);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a809a4b50addbf44b9023b5e7f9fd4d2
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,133 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Timeline;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
enum Layer : byte
|
||||
{
|
||||
Clips,
|
||||
ClipHandles,
|
||||
Markers,
|
||||
MarkerHeaderTrack,
|
||||
MarkersOnHeader
|
||||
}
|
||||
|
||||
struct LayerZOrder : IComparable<LayerZOrder>
|
||||
{
|
||||
Layer m_Layer;
|
||||
int m_ZOrder;
|
||||
|
||||
public LayerZOrder(Layer layer, int zOrder)
|
||||
{
|
||||
m_Layer = layer;
|
||||
m_ZOrder = zOrder;
|
||||
}
|
||||
|
||||
public int CompareTo(LayerZOrder other)
|
||||
{
|
||||
if (m_Layer == other.m_Layer)
|
||||
return m_ZOrder.CompareTo(other.m_ZOrder);
|
||||
return m_Layer.CompareTo(other.m_Layer);
|
||||
}
|
||||
|
||||
public static LayerZOrder operator ++(LayerZOrder x)
|
||||
{
|
||||
return new LayerZOrder(x.m_Layer, x.m_ZOrder + 1);
|
||||
}
|
||||
|
||||
public LayerZOrder ChangeLayer(Layer layer)
|
||||
{
|
||||
return new LayerZOrder(layer, m_ZOrder);
|
||||
}
|
||||
}
|
||||
|
||||
interface ILayerable
|
||||
{
|
||||
LayerZOrder zOrder { get; }
|
||||
}
|
||||
|
||||
interface IZOrderProvider
|
||||
{
|
||||
LayerZOrder Next();
|
||||
}
|
||||
|
||||
interface ILayer : IZOrderProvider
|
||||
{
|
||||
void Draw(Rect rect, WindowState state);
|
||||
}
|
||||
|
||||
abstract class ItemsLayer<T> : ILayer where T : TimelineItemGUI
|
||||
{
|
||||
// provide a buffer for time-based culling to allow for UI that extends slightly beyond the time (e.g. markers)
|
||||
// prevents popping of marker visibility.
|
||||
const int kVisibilityBufferInPixels = 10;
|
||||
|
||||
int m_PreviousLayerStateHash = -1;
|
||||
LayerZOrder m_LastZOrder;
|
||||
|
||||
public LayerZOrder Next()
|
||||
{
|
||||
m_NeedSort = true;
|
||||
return m_LastZOrder++;
|
||||
}
|
||||
|
||||
readonly List<T> m_Items = new List<T>();
|
||||
bool m_NeedSort = true;
|
||||
|
||||
public virtual void Draw(Rect rect, WindowState state)
|
||||
{
|
||||
if (m_Items.Count <= 0) return;
|
||||
|
||||
Sort();
|
||||
|
||||
// buffer to prevent flickering of markers at boundaries
|
||||
var onePixelTime = state.PixelDeltaToDeltaTime(kVisibilityBufferInPixels);
|
||||
var visibleTime = state.timeAreaShownRange + new Vector2(-onePixelTime, onePixelTime);
|
||||
var layerViewStateHasChanged = GetLayerViewStateChanged(rect, state);
|
||||
|
||||
foreach (var item in m_Items)
|
||||
{
|
||||
item.visible = item.end > visibleTime.x && item.start < visibleTime.y;
|
||||
if (!item.visible)
|
||||
continue;
|
||||
|
||||
item.Draw(rect, layerViewStateHasChanged, state);
|
||||
}
|
||||
}
|
||||
|
||||
public List<T> items => m_Items;
|
||||
|
||||
protected void AddItem(T item)
|
||||
{
|
||||
m_Items.Add(item);
|
||||
m_NeedSort = true;
|
||||
}
|
||||
|
||||
protected ItemsLayer(Layer layerOrder)
|
||||
{
|
||||
m_LastZOrder = new LayerZOrder(layerOrder, 0);
|
||||
}
|
||||
|
||||
void Sort()
|
||||
{
|
||||
if (!m_NeedSort)
|
||||
return;
|
||||
|
||||
m_Items.Sort((a, b) => a.zOrder.CompareTo(b.zOrder));
|
||||
m_NeedSort = false;
|
||||
}
|
||||
|
||||
bool GetLayerViewStateChanged(Rect rect, WindowState state)
|
||||
{
|
||||
var layerStateHash = rect.GetHashCode().CombineHash(state.viewStateHash);
|
||||
var layerViewStateHasChanged = layerStateHash != m_PreviousLayerStateHash;
|
||||
|
||||
if (Event.current.type == EventType.Layout && layerViewStateHasChanged)
|
||||
m_PreviousLayerStateHash = layerStateHash;
|
||||
|
||||
return layerViewStateHasChanged;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: ef97f39912c138b4cabdccedfb24093b
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,80 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using UnityEngine.Timeline;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
class MarkersLayer : ItemsLayer<TimelineItemGUI>
|
||||
{
|
||||
public MarkersLayer(Layer layerOrder, IRowGUI parent) : base(layerOrder)
|
||||
{
|
||||
CreateLists(parent);
|
||||
}
|
||||
|
||||
void CreateLists(IRowGUI parent)
|
||||
{
|
||||
var markerCount = parent.asset.GetMarkerCount();
|
||||
if (markerCount == 0) return;
|
||||
|
||||
var accumulator = new List<IMarker>();
|
||||
var sortedMarkers = new List<IMarker>(parent.asset.GetMarkers());
|
||||
var vm = TimelineWindowViewPrefs.GetTrackViewModelData(parent.asset);
|
||||
|
||||
sortedMarkers.Sort((lhs, rhs) =>
|
||||
{
|
||||
// Sort by time first
|
||||
var timeComparison = lhs.time.CompareTo(rhs.time);
|
||||
if (timeComparison != 0)
|
||||
return timeComparison;
|
||||
|
||||
// If there's a collision, sort by edit timestamp
|
||||
var lhsObject = lhs as object;
|
||||
var rhsObject = rhs as object;
|
||||
|
||||
if (lhsObject.Equals(null) || rhsObject.Equals(null))
|
||||
return 0;
|
||||
|
||||
var lhsHash = lhsObject.GetHashCode();
|
||||
var rhsHash = rhsObject.GetHashCode();
|
||||
|
||||
if (vm.markerTimeStamps.ContainsKey(lhsHash) && vm.markerTimeStamps.ContainsKey(rhsHash))
|
||||
return vm.markerTimeStamps[lhsHash].CompareTo(vm.markerTimeStamps[rhsHash]);
|
||||
|
||||
return 0;
|
||||
});
|
||||
|
||||
foreach (var current in sortedMarkers)
|
||||
{
|
||||
// TODO: Take zoom factor into account?
|
||||
if (accumulator.Count > 0 && Math.Abs(current.time - accumulator[accumulator.Count - 1].time) > TimeUtility.kTimeEpsilon)
|
||||
ProcessAccumulator(accumulator, parent);
|
||||
|
||||
accumulator.Add(current);
|
||||
}
|
||||
|
||||
ProcessAccumulator(accumulator, parent);
|
||||
}
|
||||
|
||||
void ProcessAccumulator(List<IMarker> accumulator, IRowGUI parent)
|
||||
{
|
||||
if (accumulator.Count == 0) return;
|
||||
|
||||
if (accumulator.Count == 1)
|
||||
{
|
||||
AddItem(new TimelineMarkerGUI(accumulator[0], parent, this));
|
||||
}
|
||||
else
|
||||
{
|
||||
// Ensure that the cluster is always considered *below* the markers it contains.
|
||||
var clusterZOrder = Next();
|
||||
AddItem(
|
||||
new TimelineMarkerClusterGUI(
|
||||
accumulator.Select(m => new TimelineMarkerGUI(m, parent, this)).ToList(),
|
||||
parent, this, clusterZOrder));
|
||||
}
|
||||
|
||||
accumulator.Clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: bea62e1faac8f9a48a4cb919ea05cb6a
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,50 @@
|
||||
using System;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Timeline;
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
class TrackDrawer : GUIDrawer
|
||||
{
|
||||
internal WindowState sequencerState { get; set; }
|
||||
|
||||
|
||||
public static TrackDrawer CreateInstance(TrackAsset trackAsset)
|
||||
{
|
||||
if (trackAsset == null)
|
||||
return Activator.CreateInstance<TrackDrawer>();
|
||||
|
||||
TrackDrawer drawer;
|
||||
|
||||
try
|
||||
{
|
||||
drawer = (TrackDrawer)Activator.CreateInstance(TimelineHelpers.GetCustomDrawer(trackAsset.GetType()));
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
drawer = Activator.CreateInstance<TrackDrawer>();
|
||||
}
|
||||
|
||||
drawer.track = trackAsset;
|
||||
return drawer;
|
||||
}
|
||||
|
||||
protected TrackAsset track { get; private set; }
|
||||
|
||||
public virtual bool HasCustomTrackHeaderButton()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public virtual void DrawTrackHeaderButton(Rect rect, WindowState state) { }
|
||||
|
||||
public virtual bool DrawTrack(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public virtual void DrawRecordingBackground(Rect trackRect, TrackAsset trackAsset, Vector2 visibleTime, WindowState state)
|
||||
{
|
||||
EditorGUI.DrawRect(trackRect, DirectorStyles.Instance.customSkin.colorTrackBackgroundRecording);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 9a0f991b6c2f45b44b92e163f9969e8e
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@ -0,0 +1,38 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
|
||||
namespace UnityEditor.Timeline
|
||||
{
|
||||
struct TrackItemsDrawer
|
||||
{
|
||||
List<ILayer> m_Layers;
|
||||
ClipsLayer m_ClipsLayer;
|
||||
|
||||
public List<TimelineClipGUI> clips => m_ClipsLayer.items;
|
||||
|
||||
public TrackItemsDrawer(IRowGUI parent)
|
||||
{
|
||||
m_Layers = null;
|
||||
m_ClipsLayer = null;
|
||||
BuildGUICache(parent);
|
||||
}
|
||||
|
||||
void BuildGUICache(IRowGUI parent)
|
||||
{
|
||||
m_ClipsLayer = new ClipsLayer(Layer.Clips, parent);
|
||||
m_Layers = new List<ILayer>
|
||||
{
|
||||
m_ClipsLayer,
|
||||
new MarkersLayer(Layer.Markers, parent)
|
||||
};
|
||||
}
|
||||
|
||||
public void Draw(Rect rect, WindowState state)
|
||||
{
|
||||
foreach (var layer in m_Layers)
|
||||
{
|
||||
layer.Draw(rect, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c7137daaeb11e8647bf1ade9b7e9aa97
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Reference in New Issue
Block a user