GraphNode GetFromCacheOrCreateNode(DebugReference reference)
{
GraphNode cacheNode = graphNodesCache.FirstOrDefault(n => n.reference.identifier.typeHashCode.Equals(reference.identifier.typeHashCode));
if (cacheNode != null)
{
cacheNode.Reinitialize(reference);
graphNodesCache.Remove(cacheNode);
graphNodes.Add(cacheNode);
return(cacheNode);
}
else
{
GraphNode node = GraphNode.Create(owner, null, reference);
if (node == null)
{
return(null);
}
graphNodes.Add(node);
owner.AddElement(node);
return(node);
}
}
public T GetDebugObjectField <T>(DebugIdentifier fieldIdentifier) where T : struct, IDebugObject
{
DebugReference fieldReference = owner.GetDebugMemory().FindObjectReference(fieldIdentifier);
Assert.IsTrue(fieldReference.IsValid);
return(owner.GetDebugMemory().ReadObject <T>(fieldReference));
}
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 }));
}
public void Reinitialize(DebugReference reference)
{
this.reference = reference;
title = Title;
UpdatePortValues();
RefreshPorts();
}
GraphNodeGroup GetGroupFromCache(DebugReference root)
{
Assert.IsTrue(graphGroupsCache != null);
foreach (var group in graphGroupsCache)
{
if (group.root.Equals(root.identifier))
{
graphGroupsCache.Remove(group);
return(group);
}
}
return(null);
}
public virtual void PostParseBuildResult()
{
if (string.IsNullOrEmpty(TargetPath) || string.IsNullOrEmpty(ProjectPath))
{
return;
}
if ((DebugSrc == null) || (DebugId == null))
{
string targetFile = GetFullPath(TargetPath);
if (QQnPath.IsAssemblyFile(targetFile) && File.Exists(targetFile))
{
DebugReference reference = AssemblyUtils.GetDebugReference(targetFile);
if (reference != null)
{
string pdbSrc = EnsureRelativePath(QQnPath.Combine(ProjectPath, Path.GetDirectoryName(TargetPath), reference.PdbFile));
FileInfo pdbTarget = new FileInfo(Path.GetFullPath(QQnPath.Combine(ProjectPath, Path.GetDirectoryName(TargetPath), Path.GetFileName(pdbSrc))));
if (pdbTarget.Exists)
{
FileInfo pdbFrom = new FileInfo(GetFullPath(pdbSrc));
if (!pdbFrom.Exists || ((pdbFrom.Length == pdbTarget.Length) && (pdbFrom.LastWriteTime == pdbTarget.LastWriteTime)))
{
pdbSrc = EnsureRelativePath(pdbTarget.FullName);
}
}
DebugSrc = pdbSrc;
DebugId = reference.DebugId;
}
else
{
string pdbFile = Path.ChangeExtension(targetFile, ".pdb");
if (ProjectOutput.ContainsKey(pdbFile) && File.Exists(pdbFile))
{
pdbFile = EnsureRelativePath(pdbFile);
DebugSrc = pdbFile;
}
}
}
}
}
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);
}
void Initialize(GraphNodeView owner, Type type, DebugReference reference)
{
this.owner = owner;
this.runtimeType = type;
this.reference = reference;
RegisterCallback <GeometryChangedEvent>(GeometryChangededCallback);
UIElementsUtils.ApplyStyleSheet(styleSheet, this);
InitializePorts();
InitializeView();
DrawDefaultInspector();
RefreshExpandedState();
RefreshPorts();
}
public static ExecutionGraphModel Create(DebugMemory?memory)
{
List <ExecutionGroupModel> groups = new List <ExecutionGroupModel>();
if (memory.HasValue)
{
ExecutionGroupModel group = ExecutionGroupModel.Create(0);
for (DebugReference reference = memory.Value.FirstOrDefault; reference.IsValid; reference = memory.Value.Next(reference))
{
if (reference.dataOnly)
{
continue;
}
if (reference.group != group.groupIndex)
{
if (group.references.Count > 0)
{
group.FindTitle(memory.Value);
groups.Add(group);
}
group = ExecutionGroupModel.Create(reference.group);
}
group.references.Add(reference);
}
if (group.references.Count > 0)
{
group.FindTitle(memory.Value);
groups.Add(group);
}
}
return(new ExecutionGraphModel()
{
groups = groups
});
}
internal static GraphNode Create(GraphNodeView owner, Type type, DebugReference reference)
{
Type nodeType = GraphNodeAttribute.GetNodeType(reference.identifier.typeHashCode);
if (nodeType != null)
{
Type runtimeType = DataTypes.GetTypeFromHashCode(reference.identifier.typeHashCode).Item1;
var graphNode =
Activator.CreateInstance(nodeType) as GraphNode;
if (graphNode == null)
{
throw new InvalidOperationException(
$"Failed to create node type {nodeType.FullName} for type {type.FullName}.");
}
graphNode.Initialize(owner, runtimeType, reference);
return(graphNode);
}
return(null);
}
public void MakePackage()
{
string logFile = QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog");
if (!File.Exists(logFile))
{
BuildInternal();
}
TBLogFile log = TBLogFile.Load(logFile);
Assert.That(!string.IsNullOrEmpty(log.Project.Name));
DebugReference reference = null;
foreach (TBLogItem item in log.Configurations[0].ProjectOutput.Items)
{
if (!item.IsShared && !item.IsCopy)
{
switch (Path.GetExtension(item.Src).ToUpperInvariant())
{
case ".PDB":
case ".DLL":
if (reference == null)
{
reference = AssemblyUtils.GetDebugReference(item.FullSrc);
Assert.That(reference, Is.Not.Null);
Assert.That(reference.PdbFile, Is.Not.Null);
}
else
{
DebugReference dr = AssemblyUtils.GetDebugReference(item.FullSrc);
Assert.That(dr, Is.Not.Null);
// Path does not have to equal; the pdb information contains the sourcepath (obj directory for c# code)
Assert.That(Path.GetFileName(dr.PdbFile), Is.EqualTo(Path.GetFileName(reference.PdbFile)));
Assert.That(dr.DebugId, Is.EqualTo(reference.DebugId));
}
break;
}
}
}
Pack pack = null;
Assert.That(PackUtils.TryCreatePack(log, out pack));
string path = QQnPath.Combine(PackagePath, "QQn.TurtleMSBuild.tpZip");
TPack tp = TPack.Create(path, pack);
using (TPack pkg = TPack.OpenFrom(path, VerificationMode.Full))
using (DirectoryMap dm = DirectoryMap.Get(ExtractPath))
{
Assert.That(pkg, Is.Not.Null);
pkg.ExtractTo(dm);
}
using (TPack pkg = TPack.OpenFrom(path, VerificationMode.Full))
{
Assert.That(pkg, Is.Not.Null);
pkg.ExtractTo(ExtractPath);
}
}
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;
}
}
}
