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.LIGHT, referenceID, null); //Material nodes can and are most likely to be children of other component nodes. objNode.AddChildNode(componentNode); byte[] bytes = new byte[24]; float[] data = new float[6]; data[0] = this.light.color.r; data[1] = this.light.color.g; data[2] = this.light.color.b; data[3] = this.light.color.a; data[4] = (float)this.light.type; data[5] = this.light.intensity; for (int i = 0; i < data.Length; i++) { Buffer.BlockCopy(BitConverter.GetBytes(data[i]), 0, bytes, 4 * i, 4); } //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.LIGHT, 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(); #if UNITY_EDITOR string assetPath = AssetDatabase.GetAssetPath(animationClip); NodeBase animationNode = CheckSharedAnimationClip(this.rootNode, assetPath); if (animationNode != null) { UInt32 animationID = animationNode.GetReferenceID(); ComponentNode componentNode = new ComponentNode(PCFResourceType.ANIMATIONCLIPREFERENCE, referenceID, null, typeof(UnityEngine.AnimationClip).Name.ToString()); objNode.AddChildNode(componentNode); byte[] bytes = BitConverter.GetBytes(animationID); JObject metaData = new JObject(); metaData["fieldName"] = this.fieldName; 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.ANIMATIONCLIPREFERENCE, resource); this.pointedID = animationID; } else { ComponentNode componentNode = new ComponentNode(PCFResourceType.ANIMATIONCLIP, referenceID, assetPath, typeof(UnityEngine.AnimationClip).Name.ToString()); objNode.AddChildNode(componentNode); EditorCurveBinding[] curveBindings = AnimationUtility.GetCurveBindings(animationClip); AnimationCurve initialCurve = AnimationUtility.GetEditorCurve(animationClip, curveBindings[0]); SerializedAnimationClip serializedAnimationClip = new SerializedAnimationClip(); serializedAnimationClip.PostWrapMode = (int)initialCurve.postWrapMode; serializedAnimationClip.PreWrapMode = (int)initialCurve.preWrapMode; for (int i = 0; i < curveBindings.Length; i++) { string propertyName = curveBindings[i].propertyName; AnimationCurve animCurve = AnimationUtility.GetEditorCurve(animationClip, curveBindings[i]); SerializedAnimationKeyFrame[] serializedKeyFrames = new SerializedAnimationKeyFrame[animCurve.keys.Length]; for (int j = 0; j < animCurve.keys.Length; j++) { serializedKeyFrames[j] = new SerializedAnimationKeyFrame(); serializedKeyFrames[j].InTagent = animCurve.keys[j].inTangent; serializedKeyFrames[j].OutTangent = animCurve.keys[j].outTangent; serializedKeyFrames[j].Time = animCurve.keys[j].time; serializedKeyFrames[j].Value = animCurve.keys[j].value; } serializedAnimationClip.AddChannel(AnimationClipUtils.GetAnimationClipChannelName(propertyName), serializedKeyFrames); } JObject metaData = new JObject(); metaData["name"] = animationClip.name; metaData["frameRate"] = animationClip.frameRate; metaData["wrapMode"] = (int)animationClip.wrapMode; metaData["legacy"] = animationClip.legacy; metaData["fieldName"] = this.fieldName; byte[] data = ProtocolBufferSerializer.SerializeAnimationClipData(serializedAnimationClip); AssetResource resource = new AssetResource(false); byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None)); resource.Serialize(referenceID, MetaDataType.JSON, metaDataBuffer, data); serializedAssets.AddResource(referenceID, PCFResourceType.ANIMATIONCLIP, resource); //Nodes store their resource when serializing componentNode.SetSerializer(this); //Make sure caller can get the actual material referenceID when serializing its metadata. this.pointedID = this.referenceID; } #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(); //Check if node hierarchy contains this material already. string path = AssetDatabase.GetAssetPath(this.material); NodeBase materialNode = CheckSharedMaterial(this.rootNode, path); //If material is already serialized (aka shared we simply serialize a pointer to it. if (materialNode != null) { //Debug.Log("Shared Material: " + path); UInt32 materialID = materialNode.GetReferenceID(); ComponentNode componentNode = new ComponentNode(PCFResourceType.MATERIALPOINTER, referenceID, null); objNode.AddChildNode(componentNode); byte[] bytes = BitConverter.GetBytes(materialID); //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.MATERIALPOINTER, resource); //Make sure caller can get the actual material referenceID when serializing its metadata. this.pointedID = materialID; } else { ComponentNode componentNode = new ComponentNode(PCFResourceType.MATERIAL, referenceID, path); //Material nodes can and are most likely to be children of other component nodes. objNode.AddChildNode(componentNode); SerializedMaterial serializedMaterial = new SerializedMaterial(); serializedMaterial.DisplayName = this.material.name; serializedMaterial.ShaderName = this.material.shader.name; Dictionary <string, SerializedMaterialProperty> materialProperties = new Dictionary <string, SerializedMaterialProperty>(); // Iterate through children and get the textures of the material. Shader shader = this.material.shader; int count = ShaderUtil.GetPropertyCount(shader); for (int i = 0; i < count; i++) { ShaderUtil.ShaderPropertyType propertyType = ShaderUtil.GetPropertyType(shader, i); string propertyName = ShaderUtil.GetPropertyName(shader, i); SerializedMaterialProperty property = null; //Color property. if (propertyType == ShaderUtil.ShaderPropertyType.Float || propertyType == ShaderUtil.ShaderPropertyType.Range) { SerializedMaterialFloatProperty prop = new SerializedMaterialFloatProperty(); prop.Val = this.material.GetFloat(propertyName); prop.PropertyType = (int)MaterialPropertyType.FloatType; property = prop; } //Vector property. if (propertyType == ShaderUtil.ShaderPropertyType.Vector) { SerializedMaterialVectorProperty prop = new SerializedMaterialVectorProperty(); Vector4 vector = this.material.GetVector(propertyName); prop.X = vector.x; prop.Y = vector.y; prop.Z = vector.z; prop.W = vector.w; prop.PropertyType = (int)MaterialPropertyType.VectorType; property = prop; } //Float property. if (propertyType == ShaderUtil.ShaderPropertyType.Color) { SerializedMaterialColorProperty prop = new SerializedMaterialColorProperty(); Color color = this.material.GetColor(propertyName); prop.R = color.r; prop.G = color.g; prop.B = color.b; prop.A = color.a; prop.PropertyType = (int)MaterialPropertyType.ColorType; property = prop; } //Texture property. if (propertyType == ShaderUtil.ShaderPropertyType.TexEnv) { Texture2D texture = (Texture2D)this.material.GetTexture(propertyName); if (texture != null) { UnitySerializeTexture textureSerializer = new UnitySerializeTexture(texture, this.rootNode); textureSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); SerializedMaterialTextureProperty prop = new SerializedMaterialTextureProperty(); prop.ReferenceID = textureSerializer.GetReferenceID(); prop.PropertyType = (int)MaterialPropertyType.TextureType; property = prop; } } materialProperties.Add(propertyName, property); } serializedMaterial.MaterialProperties = materialProperties; //Create serialized asset by converting data to a bytearray and give it to the constructor. AssetResource resource = new AssetResource(false); byte[] metaDataBuffer = ProtocolBufferSerializer.SerializedMaterial(serializedMaterial); resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, null); serializedAssets.AddResource(referenceID, PCFResourceType.MATERIAL, resource); //Nodes store their resource when serializing componentNode.SetSerializer(this); //Make sure caller can get the actual material referenceID when serializing its metadata. this.pointedID = this.referenceID; } #endif }
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(); LightprobeSerializeOpts serializeOption = null; for (int i = 0; i < serializeOptions.Length; i++) { object opt = serializeOptions[i]; if (opt is LightprobeSerializeOpts) { serializeOption = opt as LightprobeSerializeOpts; break; } } if (serializeOption == null) { return; } ComponentNode componentNode = new ComponentNode(PCFResourceType.LIGHTPROBES, referenceID, null); //Material nodes can and are most likely to be children of other component nodes. objNode.AddChildNode(componentNode); //Manually serialize SH components,. //However unity does not currently expose any way to generate the probes at runtime. //So we cannot set them directly unless the probes exist. (Fix it unity :D) byte[] serializedProbes = SerializeLightProbes(this.lightProbes); Dictionary <string, FileInfo> internalBundles = serializeOption.ListInternalBundles(); JArray bundleReferences = new JArray(); foreach (KeyValuePair <string, FileInfo> pair in internalBundles) { UnitySerializeInternalBundle bundleSerializer = new UnitySerializeInternalBundle(pair.Key, pair.Value.FullName, string.Empty, this.rootNode); bundleSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); JObject item = new JObject(); item["platform"] = pair.Key; item["referenceID"] = bundleSerializer.GetReferenceID(); bundleReferences.Add(item); } JObject metaData = new JObject(); metaData["numberOfProbes"] = this.lightProbes != null ? this.lightProbes.bakedProbes.Length : 0; metaData["bundleReferences"] = bundleReferences; //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, serializedProbes); serializedAssets.AddResource(referenceID, PCFResourceType.LIGHTPROBES, 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(); ComponentNode componentNode = new ComponentNode(PCFResourceType.COLLECTION, referenceID, null, this.type.Name.ToString()); objNode.AddChildNode(componentNode); List <UInt32> collectionIDs = new List <UInt32>(); if (this.type.IsPrimitive || this.type == typeof(string)) { //Try to serialize the collection using primitive data serialization. for (int i = 0; i < this.values.Length; i++) { UnitySerializerBase primitiveSerializer = new UnitySerializePrimitive(this.values[i], this.values[i].GetType(), "", true, this.rootNode); primitiveSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); collectionIDs.Add(primitiveSerializer.GetReferenceID()); } } else { //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); //See if there is a custom serializer defined for this type. if (serializerType != null) { 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 referenceIDMethod = serializerType.GetMethod("GetReferenceID"); object[] parameters = new object[4]; parameters[0] = serializedAssets; parameters[1] = serializeOptions; parameters[2] = componentNode; parameters[3] = postSerializeActions; serializeMethod.Invoke(serializerClass, parameters); UInt32 refID = (UInt32)referenceIDMethod.Invoke(serializerClass, null); collectionIDs.Add(refID); } } //Fallback to generic class serializer. else { for (int i = 0; i < this.values.Length; i++) { System.Object obj = this.values[i]; UnitySerializerBase classSerialize = new UnitySerializeClass(obj, this.type, "", true, this.rootNode); classSerialize.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); collectionIDs.Add(classSerialize.GetReferenceID()); } } } AssetResource resource = new AssetResource(false); byte[] metaDataBuffer = ProtocolBufferSerializer.SerializeCollectionData(this.type, this.fieldName, collectionIDs.Count, null, this.type.Assembly); resource.Serialize(this.referenceID, MetaDataType.PROTOBUF, metaDataBuffer, null); serializedAssets.AddResource(referenceID, PCFResourceType.COLLECTION, resource); }
void SerializeRecursivly(GameObject go, SerializedAssets serializedAssets, object[] serializeOptions, NodeBase node, List <Action <NodeBase> > postSerializeActions) { //Serialize an abstract representation of the node tree. NodeBase objNode = new ObjectNode(go.name, this.rootNode); //Parent objNode to ParentNode, ParentNode is always an ObjectNode. (Gameobject if you will) node.AddChildNode(objNode); Component[] objectComponents = go.GetComponents(typeof(Component)); //Some resources will serialize subresources such as materials, lightprobes and textures, they will become children of their NodeComponents. for (int i = 0; i < objectComponents.Length; i++) { if (objectComponents[i] is SkinnedMeshRenderer) { UnitySerializeSkinnedMesh skinnedMeshSerializer = new UnitySerializeSkinnedMesh(go, objectComponents[i] as SkinnedMeshRenderer, this.rootNode); skinnedMeshSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is MeshRenderer) { UnitySerializeMesh meshSerializer = new UnitySerializeMesh(go, objectComponents[i] as MeshRenderer, this.rootNode); meshSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is MonoBehaviour) { UnitySerializeScript scriptSerializer = new UnitySerializeScript(go, objectComponents[i] as MonoBehaviour, this.rootNode); scriptSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Transform) { UnitySerializeTransform transformSerializer = new UnitySerializeTransform(go, objectComponents[i] as Transform, this.rootNode); transformSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Animator) { UnitySerializeAnimator avtarSerializer = new UnitySerializeAnimator(go, objectComponents[i] as Animator, this.rootNode); avtarSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Animation) { UnitySerializeAnimation animationSerializer = new UnitySerializeAnimation(go, objectComponents[i] as Animation, this.rootNode); animationSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Camera) { UnitySerializeCamera cameraSerializer = new UnitySerializeCamera(go, objectComponents[i] as Camera, this.rootNode); cameraSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is LightProbeGroup) { UnitySerializeLightProbes lightprobeSerializer = new UnitySerializeLightProbes(go, LightmapSettings.lightProbes, this.rootNode); lightprobeSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Collider) { UnitySerializeCollider colliderSerializer = new UnitySerializeCollider(go, objectComponents[i] as Collider, this.rootNode); colliderSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } else if (objectComponents[i] is Light) { UnitySerializeLight lightSerializer = new UnitySerializeLight(go, objectComponents[i] as Light, this.rootNode); lightSerializer.Serialize(serializedAssets, serializeOptions, objNode, postSerializeActions); } } for (int i = 0; i < go.transform.childCount; i++) { GameObject child = go.transform.GetChild(i).gameObject; SerializeRecursivly(child, serializedAssets, serializeOptions, objNode, postSerializeActions); } }
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.SCRIPT, referenceID, null, this.script.GetType().Name.ToString()); //Parent top level scripts to ObjectNode. objNode.AddChildNode(scriptNode); JObject metaData = new JObject(); metaData["scriptname"] = this.script.GetType().ToString(); //Get fields using reflection FieldInfo[] fields = script.GetType().GetFields(); for (int i = 0; i < fields.Length; i++) { if (fields[i].IsPublic && !fields[i].IsStatic) { FieldInfo currentField = fields[i]; Type valueType = currentField.FieldType; //Find matching deserializer using reflection and field type as string or similar. if (valueType.IsPrimitive || valueType == typeof(string)) { UnitySerializerBase primitiveSerializer = new UnitySerializePrimitive(currentField.GetValue(script), valueType, currentField.Name, false, this.rootNode); primitiveSerializer.Serialize(serializedAssets, serializeOptions, scriptNode, postSerializeActions); } else if (typeof(IList).IsAssignableFrom(fields[i].FieldType)) { //Convoluted way to make sure we have an array of System.Object. IEnumerable collection = currentField.GetValue(script) as IEnumerable; List <System.Object> intermediateList = new List <System.Object>(); foreach (System.Object item in collection) { intermediateList.Add(item); } System.Object[] values = intermediateList.ToArray(); if (values != null && values.Length > 0) { UnitySerializerBase collectionSerializer = new UnitySerializeCollection(values, values[0].GetType(), script, currentField.Name, rootNode); collectionSerializer.Serialize(serializedAssets, serializeOptions, scriptNode, postSerializeActions); } } else if (valueType.IsClass || valueType.IsLayoutSequential) { //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 + "." + valueType.Name + "Serialization"; Type serializerType = assembly.GetType(serializerName, false); System.Object val = fields[i].GetValue(this.script); //If we have implemented a custom serializer for this type we invoke it and let it serialize relevant data. if (serializerType != null) { object serializerClass = Activator.CreateInstance(serializerType, Convert.ChangeType(val, valueType), currentField.Name, false, this.rootNode); MethodInfo serializeMethod = serializerType.GetMethod("Serialize"); object[] parameters = new object[4]; parameters[0] = serializedAssets; parameters[1] = serializeOptions; parameters[2] = scriptNode; parameters[3] = postSerializeActions; serializeMethod.Invoke(serializerClass, parameters); } else { //Use generic serializer incase not found. UnitySerializerBase classSerialize = new UnitySerializeClass(currentField.GetValue(this.script), valueType, currentField.Name, false, this.rootNode); classSerialize.Serialize(serializedAssets, serializeOptions, scriptNode, postSerializeActions); } } } } AssetResource resource = new AssetResource(false); byte[] metaDataBuffer = System.Text.Encoding.UTF8.GetBytes(metaData.ToString(Formatting.None)); resource.Serialize(this.referenceID, MetaDataType.JSON, metaDataBuffer, null); serializedAssets.AddResource(referenceID, PCFResourceType.SCRIPT, 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.ANIMATION, referenceID, null); //Component nodes must always be parented to objNodes. objNode.AddChildNode(componentNode); //Get fields using reflection PropertyInfo[] properties = animation.GetType().GetProperties(); for (int i = 0; i < properties.Length; i++) { if (properties[i].CanWrite) { PropertyInfo currentProperty = properties[i]; Type valueType = currentProperty.PropertyType; //Find matching deserializer using reflection and field type as string or similar. if (valueType.IsPrimitive || valueType == typeof(string)) { UnitySerializerBase primitiveSerializer = new UnitySerializePrimitive(currentProperty.GetValue(animation, null), valueType, currentProperty.Name, false, this.rootNode); primitiveSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); } else if (typeof(IList).IsAssignableFrom(properties[i].PropertyType)) { //Convoluted way to make sure we have an array of System.Object. IEnumerable collection = currentProperty.GetValue(animation, null) as IEnumerable; List <System.Object> intermediateList = new List <System.Object>(); foreach (System.Object item in collection) { intermediateList.Add(item); } System.Object[] values = intermediateList.ToArray(); if (values != null && values.Length > 0) { UnitySerializerBase collectionSerializer = new UnitySerializeCollection(values, values[0].GetType(), animation, currentProperty.Name, rootNode); collectionSerializer.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); } } else if (valueType.IsClass || valueType.IsLayoutSequential) { //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 + "." + valueType.Name + "Serialization"; Type serializerType = assembly.GetType(serializerName, false); System.Object val = properties[i].GetValue(this.animation, null); //If we have implemented a custom serializer for this type we invoke it and let it serialize relevant data. if (serializerType != null) { object serializerClass = Activator.CreateInstance(serializerType, Convert.ChangeType(val, valueType), currentProperty.Name, false, this.rootNode); MethodInfo serializeMethod = serializerType.GetMethod("Serialize"); object[] parameters = new object[4]; parameters[0] = serializedAssets; parameters[1] = serializeOptions; parameters[2] = componentNode; parameters[3] = postSerializeActions; serializeMethod.Invoke(serializerClass, parameters); } else { //Use generic serializer incase not found. UnitySerializerBase classSerialize = new UnitySerializeClass(currentProperty.GetValue(this.animation, null), valueType, currentProperty.Name, false, this.rootNode); classSerialize.Serialize(serializedAssets, serializeOptions, componentNode, postSerializeActions); } } } } //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.ANIMATION, resource); }