private void DrawClipBody(TrackDrawer.ClipDrawData drawData, bool drawCustomBody)
{
DirectorStyles instance = DirectorStyles.Instance;
Color colorClipHighlight = instance.customSkin.colorClipHighlight;
Color colorClipShadow = instance.customSkin.colorClipShadow;
GUIStyle gUIStyle = instance.timelineClip;
if (drawData.selected)
{
gUIStyle = instance.timelineClipSelected;
}
GUI.Box(drawData.clipCenterSection, GUIContent.none, gUIStyle);
if (drawCustomBody)
{
Rect clippedRect = drawData.clippedRect;
clippedRect.set_yMin(clippedRect.get_yMin() + 2f);
clippedRect.set_yMax(clippedRect.get_yMax() - TrackDrawer.k_ClipColoredLineThickness);
this.DrawCustomClipBody(drawData, clippedRect);
}
Rect targetRect = drawData.targetRect;
targetRect.set_yMin(targetRect.get_yMax() - TrackDrawer.k_ClipColoredLineThickness);
Color clipBaseColor = this.GetClipBaseColor(drawData.clip);
EditorGUI.DrawRect(targetRect, clipBaseColor);
EditorGUI.DrawRect(new Rect(drawData.targetRect.get_xMin(), drawData.targetRect.get_yMin(), drawData.targetRect.get_width() - 2f, 2f), colorClipHighlight);
EditorGUI.DrawRect(new Rect(drawData.targetRect.get_xMin(), drawData.targetRect.get_yMin() + 2f, 2f, drawData.targetRect.get_height()), colorClipHighlight);
EditorGUI.DrawRect(new Rect(drawData.targetRect.get_xMax() - 2f, drawData.targetRect.get_yMin(), 2f, drawData.targetRect.get_height()), colorClipShadow);
EditorGUI.DrawRect(new Rect(drawData.targetRect.get_xMin(), drawData.targetRect.get_yMax() - 2f, drawData.targetRect.get_width(), 2f), colorClipShadow);
}
private static void DrawRecordBackground(Rect trackRect)
{
DirectorStyles instance = DirectorStyles.Instance;
EditorGUI.DrawRect(trackRect, instance.customSkin.colorInfiniteTrackBackgroundRecording);
Graphics.ShadowLabel(trackRect, instance.Elipsify(DirectorStyles.recordingLabel.get_text(), trackRect, instance.fontClip), instance.fontClip, Color.get_white(), Color.get_black());
}
public static GUIStyle UssStyleForType(Type type)
{
ClearCacheIfInvalid();
GUIStyle cachedStyle;
if (s_CustomStyles.TryGetValue(type, out cachedStyle))
{
return(cachedStyle);
}
var style = DirectorStyles.GetGUIStyle(DirectorStyles.markerDefaultStyle);
var customStyleForType = CustomStyleForType(type);
if (customStyleForType != null)
{
if (IsStyleValid(customStyleForType))
{
style = DirectorStyles.GetGUIStyle(customStyleForType);
}
else
{
Debug.LogWarningFormat(k_ErrorCannotFindStyle, customStyleForType, type.Name);
}
}
s_CustomStyles.Add(type, style);
return(style);
}
public TimelineTreeView(TimelineWindow sequencerWindow, TreeViewController treeView)
{
this.m_TreeView = treeView;
this.m_TreeView.set_useExpansionAnimation(true);
TimelineTreeView.m_Styles = DirectorStyles.Instance;
this.m_State = sequencerWindow.state;
this.m_FoldoutWidth = DirectorStyles.Instance.foldout.get_fixedWidth();
}
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);
}
static void DrawClipLabel(string title, Rect availableRect, Color textColor, IconData[] leftIcons, IconData[] rightIcons, string tooltipMessage = "")
{
s_TitleContent.text = title;
var neededTextWidth = DirectorStyles.Instance.fontClip.CalcSize(s_TitleContent).x;
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);
// Atomic operation: We either show all icons or no icons at all
var showIcons = neededTextWidth / 2.0f + neededIconWidth < availableRect.width / 2.0f;
if (showIcons)
{
if (leftIcons != null)
{
DrawClipIcons(leftIcons, IconData.Side.Left, neededTextWidth, availableRect);
}
if (rightIcons != null)
{
DrawClipIcons(rightIcons, IconData.Side.Right, neededTextWidth, availableRect);
}
}
if (neededTextWidth > availableRect.width)
{
s_TitleContent.text = DirectorStyles.Elipsify(title, availableRect.width, neededTextWidth);
}
s_TitleContent.tooltip = tooltipMessage;
DrawClipName(availableRect, s_TitleContent, textColor);
}
public TimelineTreeView(TimelineWindow sequencerWindow, TreeViewController treeView)
{
m_TreeView = treeView;
m_TreeView.useExpansionAnimation = true;
m_TreeView.selectionChangedCallback += SelectionChangedCallback;
m_TreeView.contextClickOutsideItemsCallback += ContextClickOutsideItemsCallback;
m_TreeView.itemDoubleClickedCallback += ItemDoubleClickedCallback;
m_TreeView.contextClickItemCallback += ContextClickItemCallback;
m_TreeView.SetConsumeKeyDownEvents(false);
m_Styles = DirectorStyles.Instance;
m_State = sequencerWindow.state;
m_FoldoutWidth = DirectorStyles.Instance.foldout.fixedWidth;
}
public TimelineGroupGUI(TreeViewController treeview, TimelineTreeViewGUI treeviewGUI, int id, int depth, TreeViewItem parent, string displayName, TrackAsset trackAsset, bool isRoot)
: base(id, depth, parent, displayName, trackAsset, treeview, treeviewGUI)
{
m_Styles = DirectorStyles.Instance;
m_IsRoot = isRoot;
var trackPath = AssetDatabase.GetAssetPath(trackAsset);
var sequencePath = AssetDatabase.GetAssetPath(treeviewGUI.TimelineWindow.state.editSequence.asset);
if (trackPath != sequencePath)
{
m_IsReferencedTrack = true;
}
m_GroupDepth = CalculateGroupDepth(parent);
}
static void DrawMuteOverlay(DrawData data)
{
DirectorStyles styles = TimelineWindow.styles;
var colorOverlay = OverlayDrawer.CreateColorOverlay(GUIClip.Unclip(data.contentRect), styles.customSkin.colorTrackDarken);
colorOverlay.Draw();
Rect textRect = Graphics.CalculateTextBoxSize(data.contentRect, styles.fontClip, k_Muted, WindowConstants.overlayTextPadding);
var boxOverlay = OverlayDrawer.CreateTextBoxOverlay(
GUIClip.Unclip(textRect),
k_Muted.text,
styles.fontClip,
Color.white,
styles.customSkin.colorLockTextBG,
styles.displayBackground);
boxOverlay.Draw();
}
public static Color GetTrackColor(TrackAsset track)
{
if (track == null)
{
return(Color.white);
}
// Try to ensure DirectorStyles is initialized first
// Note: GUISkin.current must exist to be able do so
if (!DirectorStyles.IsInitialized && GUISkin.current != null)
{
DirectorStyles.ReloadStylesIfNeeded();
}
Color color;
if (!s_TrackColorCache.TryGetValue(track.GetType(), out color))
{
var attr = track.GetType().GetCustomAttributes(typeof(TrackColorAttribute), true);
if (attr.Length > 0)
{
color = ((TrackColorAttribute)attr[0]).color;
}
else
{
// case 1141958
// There was an error initializing DirectorStyles
if (!DirectorStyles.IsInitialized)
{
return(Color.white);
}
color = DirectorStyles.Instance.customSkin.colorDefaultTrackDrawer;
}
s_TrackColorCache[track.GetType()] = color;
}
return(color);
}
public override void Draw(Rect headerRect, Rect contentRect, WindowState state)
{
DetectTrackChanged();
UpdateDrawData(state);
UpdateInfiniteClipEditor(state.GetWindow());
var trackHeaderRect = headerRect;
var trackContentRect = contentRect;
float inlineCurveHeight = contentRect.height - GetTrackContentHeight(state);
bool hasInlineCurve = inlineCurveHeight > 0.0f;
if (hasInlineCurve)
{
trackHeaderRect.height -= inlineCurveHeight;
trackContentRect.height -= inlineCurveHeight;
}
if (Event.current.type == EventType.Repaint)
{
m_TreeViewRect = trackContentRect;
}
if (s_ArmForRecordContentOn == null)
{
s_ArmForRecordContentOn = new GUIContent(DirectorStyles.GetBackgroundImage(DirectorStyles.Instance.autoKey, StyleState.active));
}
if (s_ArmForRecordContentOff == null)
{
s_ArmForRecordContentOff = new GUIContent(DirectorStyles.GetBackgroundImage(DirectorStyles.Instance.autoKey));
}
if (s_ArmForRecordDisabled == null)
{
s_ArmForRecordDisabled = new GUIContent(DirectorStyles.GetBackgroundImage(DirectorStyles.Instance.autoKey), Styles.kArmForRecordDisabled);
}
track.SetCollapsed(!isExpanded);
RebuildGUICacheIfNecessary();
// Prevents from drawing outside of bounds, but does not effect layout or markers
bool isOwnerDrawSucceed = false;
Vector2 visibleTime = state.timeAreaShownRange;
if (drawer != null)
{
isOwnerDrawSucceed = drawer.DrawTrack(trackContentRect, track, visibleTime, state);
}
if (!isOwnerDrawSucceed)
{
using (new GUIViewportScope(trackContentRect))
DrawBackground(trackContentRect, track, visibleTime, state);
if (m_InfiniteTrackDrawer != null)
{
m_InfiniteTrackDrawer.DrawTrack(trackContentRect, track, visibleTime, state);
}
// draw after user customization so overlay text shows up
using (new GUIViewportScope(trackContentRect))
m_ItemsDrawer.Draw(trackContentRect, state);
}
DrawTrackHeader(trackHeaderRect, state);
if (hasInlineCurve)
{
var curvesHeaderRect = headerRect;
curvesHeaderRect.yMin = trackHeaderRect.yMax;
var curvesContentRect = contentRect;
curvesContentRect.yMin = trackContentRect.yMax;
DrawInlineCurves(curvesHeaderRect, curvesContentRect, state);
}
DrawTrackColorKind(headerRect);
DrawTrackState(contentRect, contentRect, track);
}
protected TimelineItemGUI(IRowGUI parent)
{
this.parent = parent;
m_Styles = DirectorStyles.Instance;
}
static void DrawClipBackground(Rect clipCenterSection, ClipBlends blends, bool selected)
{
var clipStyle = selected ? DirectorStyles.Instance.timelineClipSelected : DirectorStyles.Instance.timelineClip;
var texture = DirectorStyles.GetBackgroundImage(clipStyle);
var lineColor = DirectorStyles.Instance.customSkin.colorClipBlendLines;
// Center body
GUI.Label(clipCenterSection, GUIContent.none, clipStyle);
// Blend/Mix In
if (blends.inKind != BlendKind.None)
{
var mixInRect = blends.inRect;
if (blends.inKind == BlendKind.Ease)
{
ClipRenderer.RenderTexture(mixInRect, texture, Styles.blendMixInBckg, Color.black);
if (!selected)
{
Graphics.DrawLineAA(2.5f, new Vector3(mixInRect.xMin, mixInRect.yMax - 1f, 0), new Vector3(mixInRect.xMax, mixInRect.yMin + 1f, 0), lineColor);
}
}
else
{
var blendInColor = selected ? Color.black : DirectorStyles.Instance.customSkin.colorClipBlendYin;
ClipRenderer.RenderTexture(mixInRect, texture, Styles.blendEaseInBckg, blendInColor);
if (!selected)
{
Graphics.DrawLineAA(2.0f, new Vector3(mixInRect.xMin, mixInRect.yMin + 1f, 0), new Vector3(mixInRect.xMax, mixInRect.yMax - 1f, 0), lineColor);
}
}
Graphics.DrawLineAA(2.0f, mixInRect.max, new Vector2(mixInRect.xMax, mixInRect.yMin), lineColor);
}
// Blend/Mix Out
if (blends.outKind != BlendKind.None)
{
var mixOutRect = blends.outRect;
if (blends.outKind == BlendKind.Ease)
{
ClipRenderer.RenderTexture(mixOutRect, texture, Styles.blendMixOutBckg, Color.black);
if (!selected)
{
Graphics.DrawLineAA(2.5f, new Vector3(mixOutRect.xMin, mixOutRect.yMin + 1f, 0), new Vector3(mixOutRect.xMax, mixOutRect.yMax - 1f, 0), lineColor);
}
}
else
{
var blendOutColor = selected ? Color.black : DirectorStyles.Instance.customSkin.colorClipBlendYang;
ClipRenderer.RenderTexture(mixOutRect, texture, Styles.blendEaseOutBckg, blendOutColor);
if (!selected)
{
Graphics.DrawLineAA(2.0f, new Vector3(mixOutRect.xMin, mixOutRect.yMin + 1f, 0), new Vector3(mixOutRect.xMax, mixOutRect.yMax - 1f, 0), lineColor);
}
}
Graphics.DrawLineAA(2.0f, mixOutRect.min, new Vector2(mixOutRect.xMin, mixOutRect.yMax), lineColor);
}
}
public void Initialize()
{
this.m_DefaultSkinColors = DirectorStyles.CreateDefaultSkin();
this.m_DarkSkinColors = this.LoadColorSkin(DirectorStyles.s_DarkSkinPath);
this.m_LightSkinColors = this.LoadColorSkin(DirectorStyles.s_LightSkinPath);
}
