public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] metaDataBuffer = resource.GetMetaData();
SerializedFieldData fieldData = ProtocolBufferSerializer.DeserializeFieldData(metaDataBuffer);
string assemblyName = ProtocolBufferSerializer.GetAssemblyName(fieldData.assemblyType);
string scriptTypeName = fieldData.typeName;
string fieldName = fieldData.fieldName;
Type scriptType = null;
//Qualify type check with assembly name, GetType only looks in current assembly otherwise.
if (!string.IsNullOrEmpty(assemblyName))
{
scriptType = Type.GetType(scriptTypeName + ", " + assemblyName);
}
else
{
scriptType = Type.GetType(scriptTypeName);
}
if (scriptType != null)
{
Gradient gradient = new Gradient();
PropertySetter colorKeySetter = new PropertySetter("colorKeys", (System.Object val) => { gradient.colorKeys = val as GradientColorKey[]; });
PropertySetter alphaKeySetter = new PropertySetter("alphaKeys", (System.Object val) => { gradient.alphaKeys = val as GradientAlphaKey[]; });
List <PropertySetter> customValueSetters = new List <PropertySetter>();
customValueSetters.Add(colorKeySetter);
customValueSetters.Add(alphaKeySetter);
FieldDeserializer fieldDeserializer = new FieldDeserializer(customValueSetters, gradient);
ResourceResponse response = new ResourceResponse();
response.SetFieldDeserializer(fieldDeserializer);
for (int i = 0; i < this.ChildNodes.Count; i++)
{
UnityNodeBase child = this.ChildNodes[i];
child.Deserialize(dataBlocks, this, response, postInstallActions, optimizedLoad);
}
if (resourceResponse != null)
{
resourceResponse.GetFieldDeserializer.SetField(fieldName, gradient);
}
}
this.isDeserialized = true;
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
this.animator = parentNode.GetGameObject().AddComponent <UnityEngine.Animator>();
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] metaDataBuffer = resource.GetMetaData();
JObject metaData = JObject.Parse(System.Text.Encoding.UTF8.GetString(metaDataBuffer));
this.animator.applyRootMotion = metaData["applyRootMotion"].ToObject <bool>();
UInt32 avatarID = metaData.Value <UInt32>("avatarReferenceID");
for (int i = 0; i < this.ChildNodes.Count; i++)
{
UnityNodeBase child = this.ChildNodes[i];
ResourceResponse avatarResponse = new ResourceResponse(avatarID, (ResourceResponse response) =>
{
this.animator.avatar = response.GetAvatarRequest;
});
child.Deserialize(dataBlocks, this, avatarResponse, postInstallActions, optimizedLoad);
}
this.isDeserialized = true;
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.TRANSFORM, referenceID, null, this.transform.name);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
Vector3[] vectors = new Vector3[3];
vectors[0] = this.transform.localPosition;
vectors[1] = this.transform.localRotation.eulerAngles;
vectors[2] = this.transform.localScale;
byte[] bytes = WriteVector3ArrayToBytes(vectors);
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
resource.Serialize(referenceID, MetaDataType.UNKOWN, null, bytes);
serializedAssets.AddResource(referenceID, PCFResourceType.TRANSFORM, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
this.light = parentNode.GetGameObject().AddComponent <Light>();
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] bytes = resource.GetResourceData();
int count = (bytes.Length / 4);
float[] data = new float[count];
for (int i = 0; i < count; i++)
{
data[i] = BitConverter.ToSingle(bytes, (i * 4));
}
light.color = new Color(data[0], data[1], data[2], data[3]);
light.type = (LightType)Enum.ToObject(typeof(LightType), (int)data[4]);
light.intensity = data[5];
this.isDeserialized = true;
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
//Deserialize pointed node id.
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
UInt32 pointedNodeID = BitConverter.ToUInt32(resource.GetResourceData(), 0);
UnityNodeBase currentParent = parentNode;
while (currentParent.ParentNode != null)
{
currentParent = currentParent.ParentNode;
}
UnityNodeBase referencedNode = FindNodeWithID(currentParent, pointedNodeID);
if (referencedNode is UnityMaterialNode)
{
UnityMaterialNode materialNode = referencedNode as UnityMaterialNode;
Material mat = materialNode.GetMaterial();
ResourceResponse request = resourceResponse.CanHandle(pointedNodeID);
if (request != null)
{
request.HandleMaterialResponse(mat);
}
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode scriptNode = new ComponentNode(PCFResourceType.CLASS, referenceID, null, this.type.Name.ToString());
//Parent top level scripts to ObjectNode.
objNode.AddChildNode(scriptNode);
FieldInfo[] fields = this.type.GetFields();
for (int i = 0; i < fields.Length; i++)
{
if (fields[i].IsPublic && !fields[i].IsStatic)
{
SerializeField(serializedAssets, serializeOptions, scriptNode, postSerializeActions, fields[i]);
}
}
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeFieldData(this.type, this.fieldName, this.arrayItem, this.type.Assembly);
resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, null);
serializedAssets.AddResource(referenceID, PCFResourceType.CLASS, resource);
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.ANIMATOR, referenceID, null);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
//Serialize child node ( the avatar )
//We serialize as reference.
UnitySerializeAvatar avatarReferenceSerializer = new UnitySerializeAvatar(this.animator, this.parentGO, this.rootNode);
avatarReferenceSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions);
JObject metaData = new JObject();
//Serialize apply root motion variable in the metadata.
metaData["applyRootMotion"] = this.animator.applyRootMotion;
//Serialize avatarReference in the metadata.
metaData["avatarReferenceID"] = avatarReferenceSerializer.GetReferenceID();
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, null);
serializedAssets.AddResource(referenceID, PCFResourceType.ANIMATOR, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
if (File.Exists(this.internalBundlePath))
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.INTERNALBUNDLE, referenceID, null, platform);
//Material nodes can and are most likely to be children of other component nodes.
objNode.AddChildNode(componentNode);
JObject metaData = new JObject();
metaData["platform"] = platform;
metaData["contents"] = contents;
byte[] serializedBundle = File.ReadAllBytes(internalBundlePath);
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, serializedBundle);
serializedAssets.AddResource(referenceID, PCFResourceType.INTERNALBUNDLE, resource);
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.MESH, referenceID, null);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
//Serialize mesh into a byte array.
byte[] bytes = MeshSerializeUtilities.WriteMesh(this.meshFilter.sharedMesh, true, false);
//Serialize Material
UnitySerializeMaterial materialSerializer = new UnitySerializeMaterial(this.meshRenderer.sharedMaterial, this.rootNode);
materialSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions);
//Make sure mesh knows that material it needs.
JObject metaData = new JObject();
metaData["materialID"] = materialSerializer.GetPointerID();
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, bytes);
serializedAssets.AddResource(referenceID, PCFResourceType.MESH, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
this.camera = parentNode.GetGameObject().AddComponent <Camera>();
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] bytes = resource.GetResourceData();
int count = (bytes.Length / 4);
float[] data = new float[count];
for (int i = 0; i < count; i++)
{
data[i] = BitConverter.ToSingle(bytes, (i * 4));
}
camera.backgroundColor = new Color(data[0], data[1], data[2], data[3]);
camera.fieldOfView = data[4];
camera.aspect = data[5];
this.isDeserialized = true;
}
}
public void ReplaceResource(UInt32 referenceID, AssetResource newResource)
{
if (this.resourceDatabase.ContainsKey(referenceID))
{
this.resourceDatabase.Remove(referenceID);
this.resourceDatabase.Add(referenceID, newResource);
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
if (resource != null)
{
byte[] metaDataBuffer = resource.GetMetaData();
SerializedCollectionData collectionData = ProtocolBufferSerializer.DeserializeCollectionData(metaDataBuffer);
string assemblyName = ProtocolBufferSerializer.GetAssemblyName(collectionData.assemblyType);
string scriptTypeName = collectionData.typeName;
string fieldName = collectionData.fieldName;
int itemCount = collectionData.count;
Type scriptType = null;
//Qualify type check with assembly name, GetType only looks in current assembly otherwise.
if (!string.IsNullOrEmpty(assemblyName))
{
scriptType = Type.GetType(scriptTypeName + ", " + assemblyName);
}
else
{
scriptType = Type.GetType(scriptTypeName);
}
if (scriptType != null)
{
Array array = Array.CreateInstance(scriptType, itemCount);
if (array != null)
{
FieldDeserializer arrayDeserializer = new FieldDeserializer(array);
ResourceResponse response = new ResourceResponse();
response.SetFieldDeserializer(arrayDeserializer);
foreach (UnityNodeBase node in this.ChildNodes)
{
node.Deserialize(dataBlocks, this, response, postInstallActions, optimizedLoad);
arrayDeserializer.IncrementIndex();
}
}
if (resourceResponse != null)
{
resourceResponse.GetFieldDeserializer.SetField(fieldName, array);
}
}
}
this.isDeserialized = true;
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.SKINNEDMESH, referenceID, null);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
byte[] bytes = MeshSerializeUtilities.WriteMesh(this.skinnedMesh.sharedMesh, true, true);
//Serialize Material
UnitySerializeMaterial materialSerializer = new UnitySerializeMaterial(this.skinnedMesh.sharedMaterial, this.rootNode);
materialSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions);
//Make sure mesh knows that material it needs.
JObject metaData = new JObject();
metaData["materialID"] = materialSerializer.GetPointerID();
metaData["rootBone"] = skinnedMesh.rootBone.name;
if (skinnedMesh.probeAnchor != null)
{
metaData["probeAnchor"] = skinnedMesh.probeAnchor.name;
}
metaData["quality"] = (int)skinnedMesh.quality;
JArray bones = new JArray();
for (int i = 0; i < skinnedMesh.bones.Length; i++)
{
bones.Add(skinnedMesh.bones[i].name);
}
metaData["bones"] = bones;
JArray blendShapeWeights = new JArray();
for (int i = 0; i < skinnedMesh.sharedMesh.blendShapeCount; i++)
{
blendShapeWeights.Add(skinnedMesh.GetBlendShapeWeight(i));
}
metaData["blendShapeWeights"] = blendShapeWeights;
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, bytes);
serializedAssets.AddResource(referenceID, PCFResourceType.SKINNEDMESH, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] bytes = resource.GetResourceData();
int vectorCount = (bytes.Length / 12);
Vector3[] vectors = new Vector3[vectorCount];
for (int i = 0; i < vectorCount; i++)
{
vectors[i] = new Vector3(
BitConverter.ToSingle(bytes, (i * 12)),
BitConverter.ToSingle(bytes, (i * 12) + 4),
BitConverter.ToSingle(bytes, (i * 12) + 8)
);
}
GameObject parentGO = parentNode.GetGameObject();
//Gameobject creates a transform itself when its created, we only need to get the component.
if (parentGO != null)
{
this.transform = parentGO.GetComponent <Transform>();
}
if (this.transform != null)
{
//Get the node above the parentNode and parent to it.
Transform parentTransform = parentNode.ParentNode.GetTransform();
//Parent this transform to the object above it, if one exists.
if (parentTransform != null)
{
this.transform.SetParent(parentTransform);
}
//Set the attributes after we have parented the transform.
this.transform.localPosition = vectors[0];
this.transform.localRotation = Quaternion.Euler(vectors[1]);
this.transform.localScale = vectors[2];
}
this.isDeserialized = true;
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postserializeActions)
{
if (this.audioClip == null)
{
Debug.Log("Missing audio clip! If this is intentional ignore this message.");
return;
}
#if UNITY_EDITOR
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
AudioSerializeOpts serializeOption = null;
for (int i = 0; i < serializeOptions.Length; i++)
{
object opt = serializeOptions[i];
if (opt is AudioSerializeOpts)
{
serializeOption = opt as AudioSerializeOpts;
break;
}
}
if (serializeOption == null)
{
return;
}
ComponentNode scriptNode = new ComponentNode(PCFResourceType.AUDIO, referenceID, null, typeof(UnityEngine.AudioClip).Name.ToString());
objNode.AddChildNode(scriptNode);
bool streamed = true;
byte[] audioData = serializeOption.PackageAudio(audioClip, serializedAssets, this.referenceID, ref streamed);
JObject metaData = new JObject();
metaData["fieldName"] = this.fieldName;
metaData["arrayItem"] = this.arrayItem;
metaData["name"] = this.audioClip.name;
metaData["sampleRate"] = this.audioClip.frequency;
metaData["channels"] = this.audioClip.channels;
metaData["samples"] = this.audioClip.samples * this.audioClip.channels;
metaData["streamed"] = streamed;
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
AssetResource resource = new AssetResource(true);
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, audioData);
serializedAssets.AddResource(referenceID, PCFResourceType.AUDIO, resource);
#endif
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
#if UNITY_EDITOR
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.TEXTURE, referenceID, null);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
if (this.texture != null)
{
TextureSerializeOpts serializeOption = null;
for (int i = 0; i < serializeOptions.Length; i++)
{
object opt = serializeOptions[i];
if (opt is TextureSerializeOpts)
{
serializeOption = opt as TextureSerializeOpts;
break;
}
}
if (serializeOption == null)
{
return;
}
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
TextureDataFormat format = TextureDataFormat.Empty;
byte[] textureData = serializeOption.PackageTexture(this.texture, serializedAssets, referenceID, ref format);
JObject metaData = new JObject();
metaData["width"] = this.texture.width;
metaData["height"] = this.texture.height;
metaData["textureFormat"] = (int)format;
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, textureData);
serializedAssets.AddResource(referenceID, PCFResourceType.TEXTURE, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
#endif
}
public void AddResource(UInt32 referenceID, AssetResource resource)
{
if (this.resourceDatabase == null)
{
this.resourceDatabase = new Dictionary <UInt32, AssetResource>();
}
this.resourceDatabase.Add(referenceID, resource);
//Tracks how many resources is added to this block.
//that way we can anticipate collection size when deserializing. (Optimization)
this.objectCount++;
}
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 override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
byte[] bytes = null;
if (this.type == typeof(string))
{
if (this.value != null)
{
bytes = System.Text.Encoding.UTF8.GetBytes((string)this.value);
}
}
else if (this.type == typeof(int))
{
bytes = BitConverter.GetBytes((int)this.value);
}
else if (this.type == typeof(float))
{
bytes = BitConverter.GetBytes((float)this.value);
}
else if (this.type == typeof(double))
{
bytes = BitConverter.GetBytes((double)this.value);
}
else if (this.type == typeof(bool))
{
bytes = BitConverter.GetBytes((bool)this.value);
}
else if (this.type == typeof(byte[]))
{
bytes = (byte[])this.value;
}
if (bytes != null)
{
ComponentNode componentNode = new ComponentNode(PCFResourceType.PRIMITIVE, referenceID, null, this.type.Name.ToString());
objNode.AddChildNode(componentNode);
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeFieldData(this.type, this.fieldName, this.arrayItem, this.type.Assembly);
resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, bytes);
serializedAssets.AddResource(referenceID, PCFResourceType.PRIMITIVE, resource);
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
//If the datatype is not a primitive look for a class specific serializer to invoke.
Assembly assembly = Assembly.GetAssembly(this.GetType());
string namespaceName = this.GetType().Namespace;
string serializerName = namespaceName + "." + this.type.Name + "Serialization";
Type serializerType = assembly.GetType(serializerName, false);
List <UInt32> collectionIDs = new List <UInt32>();
//See if there is a custom serializer defined for this type.
if (serializerType != null)
{
ComponentNode componentNode = new ComponentNode(PCFResourceType.POINTERCOLLECTION, referenceID, null, this.type.Name.ToString());
objNode.AddChildNode(componentNode);
for (int i = 0; i < this.values.Length; i++)
{
System.Object obj = this.values[i];
object serializerClass = Activator.CreateInstance(serializerType, Convert.ChangeType(obj, this.type), "", true, this.rootNode);
MethodInfo serializeMethod = serializerType.GetMethod("Serialize");
MethodInfo pointerIDMethod = serializerType.GetMethod("GetPointerID");
object[] parameters = new object[4];
parameters[0] = serializedAssets;
parameters[1] = serializeOptions;
parameters[2] = componentNode;
parameters[3] = postSerializeActions;
serializeMethod.Invoke(serializerClass, parameters);
UInt32 refID = (UInt32)pointerIDMethod.Invoke(serializerClass, null);
collectionIDs.Add(refID);
}
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeCollectionData(this.type, this.fieldName, collectionIDs.Count, collectionIDs.ToArray(), this.type.Assembly);
resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, null);
serializedAssets.AddResource(referenceID, PCFResourceType.POINTERCOLLECTION, resource);
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
GameObject parentGameObject = parentNode.GetGameObject();
this.meshFilter = parentGameObject.AddComponent <MeshFilter>();
this.meshRenderer = parentGameObject.AddComponent <MeshRenderer>();
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] metaDataBuffer = resource.GetMetaData();
JObject metaData = JObject.Parse(System.Text.Encoding.UTF8.GetString(metaDataBuffer));
UInt32 materialID = metaData.Value <UInt32>("materialID");
this.mesh = MeshSerializeUtilities.ReadMesh(resource.GetResourceData(), false);
this.meshFilter.sharedMesh = this.mesh;
if (optimizedLoad)
{
//Free up cached ram memory for this mesh, disables access to mesh components like verts etc.
this.mesh.UploadMeshData(true);
}
for (int i = 0; i < this.ChildNodes.Count; i++)
{
UnityNodeBase child = this.ChildNodes[i];
//Create a request to be send down the chain of children, see if any child will handle it.
ResourceResponse materialRequest = new ResourceResponse(materialID, (ResourceResponse response) => {
meshRenderer.material = response.GetMaterialRequest;
});
child.Deserialize(dataBlocks, this, materialRequest, postInstallActions, optimizedLoad);
}
this.isDeserialized = true;
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] metaDataBuffer = resource.GetMetaData();
JObject metaData = JObject.Parse(System.Text.Encoding.UTF8.GetString(metaDataBuffer));
string scriptName = metaData["scriptname"].ToString();
Type scriptType = null;
if (scriptMask == null)
{
scriptType = Type.GetType(scriptName);
}
else if (this.scriptMask != null && this.scriptMask.Contains(scriptName))
{
scriptType = Type.GetType(scriptName);
}
if (scriptType != null)
{
this.script = parentNode.GetGameObject().AddComponent(scriptType) as MonoBehaviour;
FieldDeserializer fieldDeserializer = new FieldDeserializer(scriptType.GetFields(), this.script);
ResourceResponse response = new ResourceResponse();
response.SetFieldDeserializer(fieldDeserializer);
foreach (UnityNodeBase node in this.ChildNodes)
{
node.Deserialize(dataBlocks, this, response, postInstallActions, optimizedLoad);
}
}
this.isDeserialized = true;
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postserializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode scriptNode = new ComponentNode(PCFResourceType.GRADIENT, referenceID, null, typeof(UnityEngine.Gradient).Name.ToString());
objNode.AddChildNode(scriptNode);
GradientColorKey[] colorKeys = this.gradient.colorKeys;
System.Object[] convertedColorKeys = new System.Object[colorKeys.Length];
for (int i = 0; i < colorKeys.Length; i++)
{
GradientColorKey colorKey = colorKeys[i];
convertedColorKeys[i] = colorKey as System.Object;
}
UnitySerializeCollection colorKeySerializer = new UnitySerializeCollection(convertedColorKeys, typeof(UnityEngine.GradientColorKey), null, "colorKeys", rootNode);
colorKeySerializer.Serialize(serializedAssets, serializeOptions, scriptNode, postserializeActions);
GradientAlphaKey[] alphaKeys = this.gradient.alphaKeys;
System.Object[] convertedAlphaKeys = new System.Object[alphaKeys.Length];
for (int i = 0; i < alphaKeys.Length; i++)
{
GradientAlphaKey alphaKey = alphaKeys[i];
convertedAlphaKeys[i] = alphaKey as System.Object;
}
UnitySerializeCollection alphaKeySerializer = new UnitySerializeCollection(convertedAlphaKeys, typeof(UnityEngine.GradientAlphaKey), null, "alphaKeys", rootNode);
alphaKeySerializer.Serialize(serializedAssets, serializeOptions, scriptNode, postserializeActions);
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeFieldData(this.gradient.GetType(), this.fieldName, this.arrayItem, this.gradient.GetType().Assembly);
resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, null);
serializedAssets.AddResource(referenceID, PCFResourceType.GRADIENT, resource);
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
string jsonString = System.Text.Encoding.UTF8.GetString(resource.GetMetaData());
JObject jsonObject = JObject.Parse(jsonString);
animationClip = new AnimationClip();
animationClip.name = jsonObject.Value <string>("name");
animationClip.frameRate = jsonObject.Value <float>("frameRate");
animationClip.wrapMode = (UnityEngine.WrapMode)jsonObject.Value <int>("wrapMode");
animationClip.legacy = true;
SerializedAnimationClip serializedAnimationClip = ProtocolBufferSerializer.DeserializeAnimationClipData(resource.GetResourceData());
foreach (int key in serializedAnimationClip.AnimationChannels.Keys)
{
SerializedAnimationChannelName channel = (SerializedAnimationChannelName)key;
SerializedAnimationKeyFrame[] keyFrames = serializedAnimationClip.GetChannel(channel);
AnimationCurve curve = CreateAnimationCurve(serializedAnimationClip.PostWrapMode, serializedAnimationClip.PreWrapMode, keyFrames);
animationClip.SetCurve("", typeof(Transform), AnimationClipUtils.GetAnimationClipChannelName(channel), curve);
}
string fieldName = jsonObject.Value <string>("fieldName");
if (resourceResponse != null)
{
resourceResponse.GetFieldDeserializer.SetField(fieldName, animationClip);
}
this.isDeserialized = true;
}
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.COLLIDER, referenceID, null);
//Material nodes can and are most likely to be children of other component nodes.
objNode.AddChildNode(componentNode);
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
resource.Serialize(referenceID, MetaDataType.UNKOWN, null, null);
serializedAssets.AddResource(referenceID, PCFResourceType.COLLIDER, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postSerializeActions)
{
//Make sure this is always 36 characters long.
this.referenceID = this.rootNode.GenerateID();
AvatarSerializeOpts serializeOption = null;
for (int i = 0; i < serializeOptions.Length; i++)
{
object opt = serializeOptions[i];
if (opt is AvatarSerializeOpts)
{
serializeOption = opt as AvatarSerializeOpts;
break;
}
}
if (serializeOption == null)
{
return;
}
ComponentNode componentNode = new ComponentNode(PCFResourceType.AVATAR, referenceID, null);
//Component nodes must always be parented to objNodes.
objNode.AddChildNode(componentNode);
JObject metaData = serializeOption.SerializeAvatar(this.parentGO, this.animator);
//Create serialized asset by converting data to a bytearray and give it to the constructor.
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None));
resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, null);
serializedAssets.AddResource(referenceID, PCFResourceType.AVATAR, resource);
//Nodes store their resource when serializing
componentNode.SetSerializer(this);
}
public override void Serialize(SerializedAssets serializedAssets, object[] serializeOptions, NodeBase objNode, List <Action <NodeBase> > postserializeActions)
{
this.referenceID = this.rootNode.GenerateID();
ComponentNode componentNode = new ComponentNode(PCFResourceType.TRANSFORMPOINTER, referenceID, null, this.transform.GetType().Name.ToString());
objNode.AddChildNode(componentNode);
//Find the node this node points to in the tree.
NodeBase transformNode = FindTransformInTree(rootNode, this.transform.name);
UInt32 referencedID = transformNode.GetReferenceID();
AssetResource resource = new AssetResource(false);
byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeFieldData(this.transform.GetType(), this.fieldName, this.arrayItem, this.transform.GetType().Assembly);
resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, BitConverter.GetBytes(referencedID));
serializedAssets.AddResource(referenceID, PCFResourceType.TRANSFORMPOINTER, resource);
this.pointedID = transformNode.GetReferenceID();
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[this.resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
ResourceResponse request = resourceResponse.CanHandle(GetReferenceID());
if (request != null)
{
byte[] bundleBytes = resource.GetResourceData();
this.internalBundle = AssetBundle.LoadFromMemory(bundleBytes);
request.HandleAssetBundleResponse(this.internalBundle);
}
this.isDeserialized = true;
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
//Deserialize pointed node id.
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
byte[] bytes = resource.GetResourceData();
UInt32 referencedNodeID = BitConverter.ToUInt32(bytes, 0);
//JObject metaData = JObject.Parse(System.Text.Encoding.UTF8.GetString(metaDataBuffer));
//UInt32 referencedNodeID = metaData.Value<UInt32>("targetReferenceID");
Dictionary <UInt32, UnityNodeBase> referencedNodes = resourceResponse.GetReferencedNodes;
if (referencedNodes.ContainsKey(referencedNodeID))
{
UnityNodeBase referencedNode = referencedNodes[referencedNodeID];
Transform transform = referencedNode.GetTransform();
if (transform != null)
{
resourceResponse.GetFieldDeserializer.SetArrayItem(transform);
}
}
this.isDeserialized = true;
}
}
public override void Deserialize(Dictionary <PCFResourceType, DataBlockBase> dataBlocks,
UnityNodeBase parentNode,
ResourceResponse resourceResponse,
List <Action <UnityNodeBase> > postInstallActions,
bool optimizedLoad)
{
if (!this.isDeserialized)
{
ResourceBlock dataBlock = dataBlocks[resourceType] as ResourceBlock;
AssetResource resource = dataBlock.GetResource(this.referenceID);
UInt32 pointedNodeID = BitConverter.ToUInt32(resource.GetResourceData(), 0);
postInstallActions.Add((UnityNodeBase rootNode) => {
UnityNodeBase referencedNode = FindNodeWithID(rootNode, pointedNodeID);
if (referencedNode is UnityAnimationClipNode)
{
UnityAnimationClipNode animationClip = referencedNode as UnityAnimationClipNode;
AnimationClip animation = animationClip.GetAnimationClip();
string jsonString = System.Text.Encoding.UTF8.GetString(resource.GetMetaData());
JObject jsonObject = JObject.Parse(jsonString);
string fieldName = jsonObject.Value <string>("fieldName");
if (resourceResponse != null)
{
resourceResponse.GetFieldDeserializer.SetField(fieldName, animation);
}
}
});
this.isDeserialized = true;
}
}
