FilesExpand file tree

 main

/

SerializedFile.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

106 lines (81 loc) · 3.07 KB

 main

/

SerializedFile.cs

Copy path

Top

File metadata and controls

• Code
• Blame

106 lines (81 loc) · 3.07 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

using System;

using System.Collections.Generic;

using System.Text;

namespace UnityDataTools.FileSystem;

public struct ExternalReference

{

public string Path;

public string Guid;

public ExternalReferenceType Type;

}

public class SerializedFile : IDisposable

{

Lazy<List<ExternalReference>> m_ExternalReferences;

Lazy<ObjectInfo[]> m_Objects;

Dictionary<IntPtr, TypeTreeNode> m_TypeTreeCache = new Dictionary<IntPtr, TypeTreeNode>();

internal SerializedFileHandle m_Handle;

public IReadOnlyList<ExternalReference> ExternalReferences => m_ExternalReferences.Value.AsReadOnly();

public IReadOnlyList<ObjectInfo> Objects => Array.AsReadOnly(m_Objects.Value);

internal SerializedFile()

{

m_ExternalReferences = new Lazy<List<ExternalReference>>(GetExternalReferences);

m_Objects = new Lazy<ObjectInfo[]>(GetObjects);

}

public TypeTreeNode GetTypeTreeRoot(long objectId)

{

var r = DllWrapper.GetTypeTree(m_Handle, objectId, out var typeTreeHandle);

UnityFileSystem.HandleErrors(r);

if (m_TypeTreeCache.TryGetValue(typeTreeHandle.Handle, out var node))

{

return node;

}

node = new TypeTreeNode(typeTreeHandle, 0);

m_TypeTreeCache.Add(typeTreeHandle.Handle, node);

return node;

}

public TypeTreeNode GetRefTypeTypeTreeRoot(string className, string namespaceName, string assemblyName)

{

var r = DllWrapper.GetRefTypeTypeTree(m_Handle, className, namespaceName, assemblyName, out var typeTreeHandle);

UnityFileSystem.HandleErrors(r);

if (m_TypeTreeCache.TryGetValue(typeTreeHandle.Handle, out var node))

{

return node;

}

node = new TypeTreeNode(typeTreeHandle, 0);

m_TypeTreeCache.Add(typeTreeHandle.Handle, node);

return node;

}

private List<ExternalReference> GetExternalReferences()

{

var r = DllWrapper.GetExternalReferenceCount(m_Handle, out var count);

UnityFileSystem.HandleErrors(r);

var externalReferences = new List<ExternalReference>(count);

var path = new StringBuilder(512);

var guid = new StringBuilder(32);

for (var i = 0; i < count; ++i)

{

DllWrapper.GetExternalReference(m_Handle, i, path, path.Capacity, guid, out var externalReferenceType);

UnityFileSystem.HandleErrors(r);

externalReferences.Add(new ExternalReference() { Path = path.ToString(), Guid = guid.ToString(), Type = externalReferenceType });

}

return externalReferences;

}

private ObjectInfo[] GetObjects()

{

var r = DllWrapper.GetObjectCount(m_Handle, out var count);

UnityFileSystem.HandleErrors(r);

if (count == 0)

return null;

var objs = new ObjectInfo[count];

DllWrapper.GetObjectInfo(m_Handle, objs, count);

UnityFileSystem.HandleErrors(r);

return objs;

}

public void Dispose()

{

if (m_Handle != null && !m_Handle.IsInvalid)

{

m_Handle.Dispose();

}

}

}