public override void SetBytes(Stream file, int chunkLength, long offsetPos, bool assemblyMode)
{
int bytesToRead = chunkLength - BlockTypeLength;
int bytesRead = 0;
//Loop and create index elements.
while (bytesRead < bytesToRead)
{
byte[] elementTypeBuffer = new byte[ChunkByteLength];
file.Read(elementTypeBuffer, 0, ChunkByteLength);
int rawElementTypeValue = BitConverter.ToInt32(elementTypeBuffer, 0);
PCFResourceType resourceType = (PCFResourceType)Enum.ToObject(typeof(PCFResourceType), rawElementTypeValue);
byte[] byteOffsetBuffer = new byte[ChunkByteLength];
file.Read(byteOffsetBuffer, 0, ChunkByteLength);
int rawByteOffsetValue = BitConverter.ToInt32(byteOffsetBuffer, 0);
IndexElement element = new IndexElement(resourceType, rawByteOffsetValue);
this.indexElements.Add(element);
bytesRead += BYTES_PER_ELEMENT;
}
#if VERBOSE_LOG
Debug.Log("Indexblock length: " + bytesToRead);
#endif
}
public ComponentNode(PCFResourceType resourceType, UInt32 referenceID, string resourceIdentifier, string name = "none") : base()
{
this.resourceType = resourceType;
this.referenceID = referenceID;
this.resourceIdentifier = resourceIdentifier;
this.name = name;
}
public T Recreate <T>(UnityNodeBase parentNode, PCFResourceType loadFlags) where T : UnityNodeBase
{
UnityNodeBase recreatedNode = null;
//Allows us to mask nodes to load, makes it easier to do quick lookup of specific things. (like reading script data, no need to load textures etc)
if ((this.resourceType & loadFlags) != 0)
{
//Create implementation specific node based on typetree info.
recreatedNode = nodeFactory.CreateNodeImplementation(this.nodeName, this.resourceType, this.referenceID);
}
//If we are not the root node we will have a parent.
if (parentNode != null && recreatedNode != null)
{
parentNode.AddChildNode(recreatedNode);
}
if (this.childNodes != null)
{
for (int i = 0; i < this.childNodes.Count; i++)
{
this.childNodes[i].Recreate <T>(recreatedNode, loadFlags);
}
}
//Only true for root node.
if (parentNode == null)
{
return(recreatedNode as T);
}
return(null);
}
public ResourceBlock(PCFResourceType resourceType, bool streamResources = false)
{
this.blockType = BitConverter.GetBytes((int)PCFBlockTypes.RESOURCEBLOCK);
this.resourceType = BitConverter.GetBytes((int)resourceType);
this.streamResources = streamResources;
this.objectCount = 0;
}
public NodeResource(PCFResourceType resourceType, UInt32 referenceID, string name)
{
this.serializedResourceType = BitConverter.GetBytes((int)resourceType);
this.serializedReferenceID = BitConverter.GetBytes(referenceID);
this.serializedNodeName = System.Text.Encoding.UTF8.GetBytes(name);
this.serializedNodeNameLength = BitConverter.GetBytes(this.serializedNodeName.Length);
this.childNodes = new List <NodeResource>();
this.serializedChildCount = BitConverter.GetBytes(childNodes.Count);
}
public static NodeResource DeserializeNode(Stream file, ref int bytesRead, bool readNames, bool assemblyMode)
{
file.Read(CHUNK_BYTE_BUFFER, 0, ChunkByteLength);
int childCount = BitConverter.ToInt32(CHUNK_BYTE_BUFFER, 0);
bytesRead += ChunkByteLength;
file.Read(CHUNK_BYTE_BUFFER, 0, ChunkByteLength);
int rawResourceTypeValue = BitConverter.ToInt32(CHUNK_BYTE_BUFFER, 0);
PCFResourceType resourceType = (PCFResourceType)Enum.ToObject(typeof(PCFResourceType), rawResourceTypeValue);
bytesRead += ChunkByteLength;
file.Read(CHUNK_BYTE_BUFFER, 0, ChunkByteLength);
UInt32 referenceID = BitConverter.ToUInt32(CHUNK_BYTE_BUFFER, 0);
bytesRead += ChunkByteLength;
file.Read(CHUNK_BYTE_BUFFER, 0, ChunkByteLength);
int nameLength = BitConverter.ToInt32(CHUNK_BYTE_BUFFER, 0);
bytesRead += ChunkByteLength;
string nodeName = null;
if (readNames)
{
file.Read(NODE_NAME_BUFFER, 0, nameLength);
nodeName = System.Text.Encoding.UTF8.GetString(NODE_NAME_BUFFER, 0, nameLength);
}
else
{
//Object nodes must have names read in because other nodes may reference them by name.
if (resourceType == PCFResourceType.OBJECT || resourceType == PCFResourceType.TRANSFORM)
{
file.Read(NODE_NAME_BUFFER, 0, nameLength);
nodeName = System.Text.Encoding.UTF8.GetString(NODE_NAME_BUFFER, 0, nameLength);
}
else
{
nodeName = DEFAULT_NODE_NAME;
file.Seek(nameLength, SeekOrigin.Current);
}
}
bytesRead += nameLength;
return(new NodeResource(resourceType, referenceID, nodeName, childCount, assemblyMode));
}
public void AddResource(uint refID, PCFResourceType resourceType, AssetResource resource)
{
if (this.dataBlocks.ContainsKey(resourceType))
{
ResourceBlock dataBlock = this.dataBlocks[resourceType] as ResourceBlock;
dataBlock.AddResource(refID, resource);
}
else
{
ResourceBlock block = new ResourceBlock(resourceType);
block.AddResource(refID, resource);
this.dataBlocks.Add(resourceType, block);
}
}
public UnityNodeBase GetChildNodeByType(PCFResourceType type)
{
if (this.ChildNodes != null)
{
for (int i = 0; i < this.ChildNodes.Count; i++)
{
UnityNodeBase child = this.ChildNodes[i];
if (child.GetResourceType() == type)
{
return(child);
}
}
}
return(null);
}
public NodeResource(PCFResourceType resourceType, UInt32 referenceID, string name, int childCount, bool assemblyMode)
{
if (assemblyMode)
{
this.serializedResourceType = BitConverter.GetBytes((int)resourceType);
this.serializedReferenceID = BitConverter.GetBytes(referenceID);
this.serializedNodeName = System.Text.Encoding.UTF8.GetBytes(name);
this.serializedNodeNameLength = BitConverter.GetBytes(this.serializedNodeName.Length);
this.childNodes = new List <NodeResource>();
this.serializedChildCount = BitConverter.GetBytes(childCount);
}
this.resourceType = resourceType;
this.referenceID = referenceID;
this.nodeName = name;
this.numberOfChildren = childCount;
}
void PopulateReferencedNodes(Dictionary <UInt32, UnityNodeBase> referencedNodes, UnityNodeBase node)
{
if (referencedNodes.ContainsKey(node.GetReferenceID()))
{
referencedNodes[node.GetReferenceID()] = node;
}
List <UnityNodeBase> children = node.ChildNodes;
for (int i = 0; i < children.Count; i++)
{
UnityNodeBase child = children[i];
PCFResourceType type = child.GetResourceType();
if (type == PCFResourceType.ROOT || type == PCFResourceType.OBJECT || type == PCFResourceType.TRANSFORM)
{
PopulateReferencedNodes(referencedNodes, children[i]);
}
}
}
private void FindTransformsInHierarchy(UnityNodeBase node, Dictionary <string, Transform> mapping)
{
if (node.GetResourceType() == PCFResourceType.TRANSFORM)
{
Transform trans = node.GetTransform();
mapping.Add(node.GetName(), trans);
}
for (int i = 0; i < node.ChildNodes.Count; i++)
{
UnityNodeBase child = node.ChildNodes[i];
PCFResourceType type = child.GetResourceType();
//Optimize search by not going into subtress that do not contain bones.
if (type == PCFResourceType.ROOT || type == PCFResourceType.OBJECT || type == PCFResourceType.TRANSFORM)
{
FindTransformsInHierarchy(child, mapping);
}
}
}
public UnityColliderNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.COLLIDER;
}
public UnityNodeBase CreateNodeImplementation(string nodeName, PCFResourceType resourceType, UInt32 referenceID)
{
UnityNodeBase recreatedNode = null;
if (this.customCreators != null && this.customCreators.ContainsKey(resourceType))
{
recreatedNode = this.customCreators[resourceType](nodeName, resourceType, referenceID);
}
else
{
switch (resourceType)
{
case PCFResourceType.ROOT:
recreatedNode = new UnityRootNode(nodeName, referenceID);
break;
case PCFResourceType.OBJECT:
recreatedNode = new UnityObjectNode(nodeName, referenceID);
break;
case PCFResourceType.TRANSFORM:
recreatedNode = new UnityTransformNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.TRANSFORMPOINTER:
recreatedNode = new UnityTransformPointerNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.MESH:
recreatedNode = new UnityMeshNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.ANIMATOR:
recreatedNode = new UnityAnimatorNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.AUDIO:
recreatedNode = new UnityAudioNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.AVATAR:
recreatedNode = new UnityAvatarReferenceNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.SKINNEDMESH:
recreatedNode = new UnitySkinnedMeshNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.SCRIPT:
recreatedNode = new UnityScriptNode(nodeName, resourceType, referenceID, null);
break;
case PCFResourceType.MATERIAL:
recreatedNode = new UnityMaterialNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.MATERIALPOINTER:
recreatedNode = new UnityMaterialPointerNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.TEXTURE:
recreatedNode = new UnityTextureNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.CAMERA:
recreatedNode = new UnityCameraNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.LIGHT:
recreatedNode = new UnityLightNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.LIGHTPROBES:
recreatedNode = new UnityLightProbesNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.COLLIDER:
recreatedNode = new UnityColliderNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.PRIMITIVE:
recreatedNode = new UnityPrimitiveNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.COLLECTION:
recreatedNode = new UnityCollectionNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.POINTERCOLLECTION:
recreatedNode = new UnityPointerCollectionNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.CLASS:
recreatedNode = new UnityClassNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.INTERNALBUNDLE:
recreatedNode = new UnityInternalBundleNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.GRADIENT:
recreatedNode = new UnityGradientNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.ANIMATION:
recreatedNode = new UnityAnimationNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.ANIMATIONCLIP:
recreatedNode = new UnityAnimationClipNode(nodeName, resourceType, referenceID);
break;
case PCFResourceType.ANIMATIONCLIPREFERENCE:
recreatedNode = new UnityAnimationClipPointerNode(nodeName, resourceType, referenceID);
break;
}
}
return(recreatedNode);
}
public UnityAnimationClipPointerNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.ANIMATIONCLIPREFERENCE;
}
public UnityPrimitiveNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.PRIMITIVE;
}
public void LoadFile(PCFResourceType loadFlags, bool streamResources, bool assemblyMode = false)
{
LoadDataFromDisk(loadFlags, streamResources, assemblyMode);
}
public UnityTransformPointerNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.TRANSFORMPOINTER;
}
public UnityAudioNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.AUDIO;
}
public UnityAnimatorNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.ANIMATOR;
}
public UnityScriptNode(string name, PCFResourceType resourceType, UInt32 referenceID, List <string> scriptMask) : base(name, resourceType, referenceID)
{
this.scriptMask = scriptMask;
this.resourceType = PCFResourceType.SCRIPT;
}
public UnityGradientNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.GRADIENT;
}
public UnityClassNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.CLASS;
}
void LoadDataFromDisk(PCFResourceType loadFlags, bool streamResources, bool assemblyMode)
{
Stream file = this.path.GetFileStream(FileMode.Open);
//Load header first.
this.fileHeader = LoadHeader(file);
int bytesRead = HeaderByteLength;
int fileLength = (int)file.Length;
while (bytesRead < fileLength)
{
int chunkLength = GetNextSegmentLength(file);
PCFBlockTypes blockType = GetNextBlockType(file);
DataBlockBase block = null;
PCFResourceType resourceType = PCFResourceType.NONE;
if (blockType == PCFBlockTypes.INDEXBLOCK)
{
block = new IndexBlock();
this.blockData.Add(PCFResourceType.INDEX, block);
}
else if (blockType == PCFBlockTypes.NODEBLOCK)
{
block = new NodeBlock(loadFlags);
this.blockData.Add(PCFResourceType.NODE, block);
}
else if (blockType == PCFBlockTypes.RESOURCEBLOCK)
{
//Read 4 bytes to determine resourcetype.
file.Read(INT_BUFFER, 0, ChunkByteLength);
int rawResourceTypeValue = BitConverter.ToInt32(INT_BUFFER, 0);
resourceType = (PCFResourceType)Enum.ToObject(typeof(PCFResourceType), rawResourceTypeValue);
//Allows us to mask what blocks to read in from file.
if ((resourceType & loadFlags) != 0)
{
block = new ResourceBlock(resourceType, streamResources);
this.blockData.Add(resourceType, block);
}
}
else
{
Debug.LogError("Unknown block type");
}
//Increment file position, make sure to count the chunk size bytes.
bytesRead += chunkLength + ChunkByteLength;
if (block != null)
{
if (memStream)
{
int bytsOffset = ChunkByteLength;
if (blockType == PCFBlockTypes.RESOURCEBLOCK)
{
bytsOffset += ChunkByteLength;
}
long fileStreamPos = file.Position;
byte[] streamBytes = new byte[chunkLength - bytsOffset];
file.Read(streamBytes, 0, chunkLength - bytsOffset);
Stream stream = new MemoryStream(streamBytes);
block.SetBytes(stream, chunkLength, fileStreamPos, assemblyMode);
}
else
{
//Will internally read from file and increment its position.
block.SetBytes(file, chunkLength, 0, assemblyMode);
}
}
else
{
//Manually seek to next chunk incase SetBytes was never called.
file.Seek(bytesRead, SeekOrigin.Begin);
}
}
if (file != null)
{
//Stop reading pcf file.
file.Close();
}
}
private byte[] byteOffset; // 4 Bytes UINT32
public IndexElement(PCFResourceType elementType, int byteOffset)
{
this.elementType = BitConverter.GetBytes((int)elementType);
this.byteOffset = BitConverter.GetBytes(byteOffset);
}
public UnitySkinnedMeshNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.SKINNEDMESH;
}
public UnityAvatarReferenceNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.AVATAR;
}
public UnityCameraNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.CAMERA;
}
public UnityPointerCollectionNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.POINTERCOLLECTION;
}
public UnityMaterialNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.MATERIAL;
}
public UnityLightProbesNode(string name, PCFResourceType resourceType, UInt32 referenceID) : base(name, resourceType, referenceID)
{
this.resourceType = PCFResourceType.LIGHTPROBES;
}
