internal static object ReadObjectGeneric(this DebugMemory memory, DebugReference reference)
        {
            Type debugObjectType = DataTypes.GetTypeFromHashCode(reference.identifier.typeHashCode).Item1;

            MethodInfo method        = typeof(DebugMemory).GetMethod(nameof(DebugMemory.ReadObject), BindingFlags.Instance | BindingFlags.Public);
            MethodInfo genericMethod = method.MakeGenericMethod(new Type[] { debugObjectType });

            return(genericMethod.Invoke(memory, new object[] { reference }));
        }
Пример #2
0
        public void UpdateSelection()
        {
            for (int i = 0; i < Debugger.frameDebugger.NumSelected; ++i)
            {
                SelectedFrameDebugProvider selected = Debugger.frameDebugger.GetSelected(i);

                IMotionSynthesizerProvider synthesizerProvider = selected.providerInfo.provider as IMotionSynthesizerProvider;
                if (synthesizerProvider == null || !synthesizerProvider.IsSynthesizerInitialized)
                {
                    continue;
                }

                ref MotionSynthesizer synthesizer = ref synthesizerProvider.Synthesizer.Ref;

                DebugMemory debugMemory = synthesizer.ReadDebugMemory;

                if (selected.metadata != null)
                {
                    DebugIdentifier identifier = (DebugIdentifier)selected.metadata;
                    if (debugMemory.FindObjectReference(identifier).IsValid)
                    {
                        break;
                    }
                    else
                    {
                        selected.metadata = null;
                    }
                }

                for (DebugReference reference = debugMemory.FirstOrDefault; reference.IsValid; reference = debugMemory.Next(reference))
                {
                    if (!DataTypes.IsValidType(reference.identifier.typeHashCode))
                    {
                        continue;
                    }

                    Type debugType = DataTypes.GetTypeFromHashCode(reference.identifier.typeHashCode).Item1;
                    if (typeof(IMotionMatchingQuery).IsAssignableFrom(debugType))
                    {
                        selected.metadata = reference.identifier;
                        break;
                    }
                }

                Debugger.frameDebugger.TrySelect(selected.providerInfo.provider, selected.metadata);
            }
Пример #3
0
        public void FindTitle(DebugMemory memory)
        {
            foreach (DebugReference reference in references)
            {
                if (DataTypes.IsValidType(reference.identifier.typeHashCode))
                {
                    Type type = DataTypes.GetTypeFromHashCode(reference.identifier.typeHashCode).Item1;
                    if (typeof(IMotionMatchingQuery).IsAssignableFrom(type))
                    {
                        object debugObject = memory.ReadObjectGeneric(reference);
                        title = (debugObject as IMotionMatchingQuery).DebugTitle;

                        if (debugObject is IDisposable disposable)
                        {
                            disposable.Dispose();
                        }

                        break;
                    }
                }
            }
        }
Пример #4
0
        void DrawCostTimeline(FrameDebugProviderInfo providerInfo, IFrameAggregate aggregate, TimelineWidget.DrawInfo drawInfo)
        {
            Rect selectedRect = drawInfo.timeline.drawRect;
            int  width        = (int)selectedRect.width;
            int  height       = (int)selectedRect.height;

            if (width * height == 0)
            {
                return;
            }

            if (aggregate.IsEmpty)
            {
                return;
            }

            IMotionSynthesizerProvider synthesizerProvider = providerInfo.provider as IMotionSynthesizerProvider;

            if (synthesizerProvider == null || !synthesizerProvider.IsSynthesizerInitialized)
            {
                return;
            }

            DebugMemory debugMemory = synthesizerProvider.Synthesizer.Ref.ReadDebugMemory;

            foreach (SelectedFrameDebugProvider selected in Debugger.frameDebugger.Selection)
            {
                if (selected.providerInfo.uniqueIdentifier == providerInfo.uniqueIdentifier)
                {
                    CreateAndClearTexture(width, height);

                    if (selected.metadata != null)
                    {
                        DebugIdentifier selectedIdentifier = (DebugIdentifier)selected.metadata;
                        DebugReference  reference          = debugMemory.FindObjectReference(selectedIdentifier);

                        if (reference.IsValid)
                        {
                            object selectedObject = debugMemory.ReadObjectGeneric(reference);

                            if (selectedObject is IMotionMatchingQuery query)
                            {
                                DrawCostTimeline(query.DebugName.GetHashCode(), (DebugCostAggregate)aggregate, drawInfo);
                            }

                            if (selectedObject is IDisposable disposable)
                            {
                                disposable.Dispose();
                            }
                        }
                    }

                    m_CacheTexture.SetPixels(m_CachePixels);
                    m_CacheTexture.Apply();

                    GUI.DrawTexture(selectedRect, m_CacheTexture);

                    return;
                }
            }
        }