public void OnPostDraw()
        {
            if (m_SelectedAnimFrame.IsValid)
            {
                AnimationDebugRecord animStateRecord = Debugger.frameDebugger.FindAggregate <AnimationDebugRecord>(m_SelectedAnimFrame.providerIdentifier);
                if (animStateRecord == null)
                {
                    m_SelectedAnimFrame = AnimationFrameIdentifier.CreateInvalid();
                    return;
                }

                Assert.IsTrue(m_SelectedAnimFrame.animIndex < animStateRecord.AnimationRecords.Count);
                if (m_SelectedAnimFrame.animIndex >= animStateRecord.AnimationRecords.Count)
                {
                    m_SelectedAnimFrame = AnimationFrameIdentifier.CreateInvalid();
                    return;
                }

                AnimationRecord animRecord = animStateRecord.AnimationRecords[m_SelectedAnimFrame.animIndex];

                Assert.IsTrue(m_SelectedAnimFrame.animFrameIndex < animRecord.animFrames.Count);
                if (m_SelectedAnimFrame.animFrameIndex >= animRecord.animFrames.Count)
                {
                    m_SelectedAnimFrame = AnimationFrameIdentifier.CreateInvalid();
                    return;
                }

                AnimationFrameInfo animFrame = animRecord.animFrames[m_SelectedAnimFrame.animFrameIndex];

                string  label     = $"{animRecord.animName}\nFrame:{animFrame.animFrame:0.00}\nWeight:{animFrame.weight:0.00}";
                Vector2 labelSize = TimelineWidget.GetLabelSize(label);

                Rect toolTipRect = new Rect(Event.current.mousePosition.x + 20, Event.current.mousePosition.y, labelSize.x + 5.0f, labelSize.y + 5.0f);

                TimelineWidget.DrawRectangleWithDetour(toolTipRect, kTooltipBackgroundColor, kTooltipDetourColor);
                TimelineWidget.DrawLabel(toolTipRect, label, kTooltipTextColor);

                m_SelectedAnimFrame = AnimationFrameIdentifier.CreateInvalid();
            }
        }
Ejemplo n.º 2
0
        void DrawDebuggerTimeline()
        {
            IEnumerable <FrameDebugProviderInfo> providers = Debugger.frameDebugger.NumSelected == 0 ? Debugger.frameDebugger.ProviderInfos : Debugger.frameDebugger.Selection.Select(p => p.providerInfo);

            var  lastRect = GUILayoutUtility.GetLastRect();
            Rect rt       = GUILayoutUtility.GetRect(lastRect.width, 54);

            List <float> timelineHeights = new List <float>();

            foreach (FrameDebugProviderInfo provider in providers)
            {
                timelineHeights.Add(kCharacterNameOffset);
                rt.height += kCharacterNameOffset;

                List <IFrameAggregate> frameAggregates = Debugger.frameDebugger.GetFrameAggregates(provider.uniqueIdentifier);
                foreach (IFrameAggregate frameAggregate in frameAggregates)
                {
                    float timelineHeight = m_CustomDrawers[frameAggregate.GetType()].GetDrawHeight(frameAggregate);
                    timelineHeights.Add(timelineHeight);
                    rt.height += timelineHeight;
                }
            }

            GUI.BeginGroup(rt);
            {
                Rect rect = new Rect(0, 0, rt.width, rt.height);

                if (m_BackgroundColor == Color.white)
                {
                    m_BackgroundColor = EditorGUIUtility.isProSkin ? new Color(0.12f, 0.12f, 0.12f, 0.78f) : new Color(0.66f, 0.66f, 0.66f, 0.78f);
                }

                GUI.color = m_BackgroundColor;
                GUI.DrawTexture(rect, EditorGUIUtility.whiteTexture);

                TimelineWidget.DrawInfo drawInfo = TimelineWidget.DrawInfo.Create(rect, m_DebuggerTimeline.RangeStart, m_DebuggerTimeline.RangeEnd, m_DebuggerTimeline.SelectedRangeStart, m_DebuggerTimeline.SelectedRangeEnd);
                drawInfo.layout = new TimelineWidget.DrawRangeInfo()
                {
                    drawRect  = rect,
                    startTime = m_DebuggerTimeline.RangeStart,
                    endTime   = m_DebuggerTimeline.RangeEnd
                };

                drawInfo.timeline.drawRect.y += kBeginOffset;

                int timelineIndex = 0;

                Color highlightColor = Debugger.instance.rewind ? new Color(0.0f, 0.25f, 0.5f, 0.1f) : new Color(0.8f, 0.0f, 0.0f, 0.2f);

                if (providers.Count() > 0)
                {
                    foreach (FrameDebugProviderInfo provider in providers)
                    {
                        List <IFrameAggregate> frameAggregates = Debugger.frameDebugger.GetFrameAggregates(provider.uniqueIdentifier);

                        // Display name
                        string displayName = provider.displayName;

                        drawInfo.timeline.drawRect.height = kCharacterNameRectangleHeight;

                        Vector2 labelSize       = TimelineWidget.GetLabelSize(displayName);
                        Rect    displayNameRect = drawInfo.timeline.drawRect;
                        displayNameRect.x     = drawInfo.layout.drawRect.x;
                        displayNameRect.width = drawInfo.layout.drawRect.width;
                        TimelineWidget.DrawRectangle(displayNameRect, new Color(0.1f, 0.1f, 0.1f, 1.0f));
                        TimelineWidget.DrawLabel(new Rect(displayNameRect.x + 10.0f, displayNameRect.y, labelSize.x, kCharacterNameRectangleHeight), displayName, Color.white);

                        drawInfo.timeline.drawRect.y += timelineHeights[timelineIndex++];

                        drawInfo.timeline.drawRect.height = 0.0f;

                        int providerTimelineIndex = timelineIndex;
                        foreach (IFrameAggregate frameAggregate in frameAggregates)
                        {
                            drawInfo.timeline.drawRect.height += timelineHeights[providerTimelineIndex++];
                        }

                        Rect highlightRect = new Rect(drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeStart) - 2.0f,
                                                      drawInfo.timeline.drawRect.y - 2.0f,
                                                      drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeEnd) - drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeStart) + 4.0f,
                                                      drawInfo.timeline.drawRect.height + 2.0f);

                        TimelineWidget.DrawRange(highlightRect, highlightColor);

                        foreach (IFrameAggregate frameAggregate in frameAggregates)
                        {
                            float timelineHeight = timelineHeights[timelineIndex++];
                            drawInfo.timeline.drawRect.height = timelineHeight;

                            m_CustomDrawers[frameAggregate.GetType()].Draw(provider, frameAggregate, drawInfo);

                            drawInfo.timeline.drawRect.y += timelineHeight;
                        }


                        if (Debugger.instance.IsState(Debugger.State.Record))
                        {
                            TimelineWidget.DrawRectangleDetour(highlightRect, Color.red, 2.0f);
                        }
                    }
                }
                else
                {
                    Rect highlightRect = new Rect(drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeStart) - 2.0f,
                                                  drawInfo.layout.drawRect.y,
                                                  drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeEnd) - drawInfo.GetPixelPosition(m_DebuggerTimeline.SelectedRangeStart) + 4.0f,
                                                  drawInfo.layout.drawRect.height);

                    TimelineWidget.DrawRange(highlightRect, highlightColor);

                    if (Debugger.instance.IsState(Debugger.State.Record))
                    {
                        TimelineWidget.DrawRectangleDetour(highlightRect, Color.red, 2.0f);
                    }
                }

                TimelineWidget.DrawNotations(drawInfo);

                m_DebuggerTimeline.Update(rect, Debugger.instance.rewind ? -1.0f : Debugger.instance.time);

                var debugger = Debugger.instance;

                if (Application.isPlaying)
                {
                    Color cursorColor = new Color(0.5f, 0.5f, 0.0f, 1.0f);

                    TimelineWidget.DrawLineAtTime(
                        drawInfo, debugger.rewindTime,
                        cursorColor);
                }

                foreach (var drawer in m_CustomDrawers)
                {
                    drawer.Value.OnPostDraw();
                }

                if (debugger.isActive)
                {
                    if (rect.Contains(Event.current.mousePosition))
                    {
                        var e = Event.current;

                        if (e.button == 0 && !e.alt)
                        {
                            if (e.type == EventType.MouseDrag || e.type == EventType.MouseDown || e.type == EventType.MouseUp)
                            {
                                e.Use();

                                m_DebuggerTimeline.Repaint = true;
                                EditorGUIUtility.AddCursorRect(rect, MouseCursor.Arrow);

                                float currentTime =
                                    m_DebuggerTimeline.GetCurrentPositionFromMouse(
                                        rect, Event.current.mousePosition);

                                float start = m_DebuggerTimeline.SelectedRangeStart;
                                float end   = m_DebuggerTimeline.SelectedRangeEnd;

                                debugger.rewindTime = Mathf.Clamp(currentTime, start, end);

                                debugger.rewind = debugger.rewind || currentTime <= end;
                            }
                        }
                    }
                }

                GUI.EndGroup();
            }

            GUILayout.Space(5 + rt.height);
        }