网站设建设,深圳网站建设lxhd,网站留言表格怎么做,一流的盐城网站开发文章目录 前言一、可序列化字典类普通字典简单的使用可序列化字典简单的使用 二、序列化场景三、序列化vector四、序列化color五、序列化旋转Quaternion完结 前言
自定义序列化的主要原因#xff1a;
可读性#xff1a;使数据结构更清晰#xff0c;便于理解和维护。优化 I… 文章目录 前言一、可序列化字典类普通字典简单的使用可序列化字典简单的使用 二、序列化场景三、序列化vector四、序列化color五、序列化旋转Quaternion完结 前言
自定义序列化的主要原因
可读性使数据结构更清晰便于理解和维护。优化 Inspector提供更友好的用户界面方便编辑和查看数据。控制序列化实现特定的序列化逻辑灵活处理数据。比如在保存或加载时进行特定的转换或处理。性能提升减少内存占用提高序列化和反序列化的效率。易于扩展根据项目需求灵活添加字段和功能。类型安全确保使用正确的数据类型减少错误。
一、可序列化字典类
Unity 无法序列化标准词典。这意味着它们不会在检查器中显示或编辑 也不会在启动时实例化。一个经典的解决方法是将键和值存储在单独的数组中并在启动时构造字典。
我们使用gitthub大佬的源码即可此项目提供了一个通用字典类及其自定义属性抽屉来解决此问题。 源码地址https://github.com/azixMcAze/Unity-SerializableDictionary
你可以选择下载源码也可以直接复制我下面的代码我把主要代码提出来了 SerializableDictionary.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using UnityEngine;public abstract class SerializableDictionaryBase
{public abstract class Storage {}protected class DictionaryTKey, TValue : System.Collections.Generic.DictionaryTKey, TValue{public Dictionary() {}public Dictionary(IDictionaryTKey, TValue dict) : base(dict) {}public Dictionary(SerializationInfo info, StreamingContext context) : base(info, context) {}}
}[Serializable]
public abstract class SerializableDictionaryBaseTKey, TValue, TValueStorage : SerializableDictionaryBase, IDictionaryTKey, TValue, IDictionary, ISerializationCallbackReceiver, IDeserializationCallback, ISerializable
{DictionaryTKey, TValue m_dict;[SerializeField]TKey[] m_keys;[SerializeField]TValueStorage[] m_values;public SerializableDictionaryBase(){m_dict new DictionaryTKey, TValue();}public SerializableDictionaryBase(IDictionaryTKey, TValue dict){ m_dict new DictionaryTKey, TValue(dict);}protected abstract void SetValue(TValueStorage[] storage, int i, TValue value);protected abstract TValue GetValue(TValueStorage[] storage, int i);public void CopyFrom(IDictionaryTKey, TValue dict){m_dict.Clear();foreach (var kvp in dict){m_dict[kvp.Key] kvp.Value;}}public void OnAfterDeserialize(){if(m_keys ! null m_values ! null m_keys.Length m_values.Length){m_dict.Clear();int n m_keys.Length;for(int i 0; i n; i){m_dict[m_keys[i]] GetValue(m_values, i);}m_keys null;m_values null;}}public void OnBeforeSerialize(){int n m_dict.Count;m_keys new TKey[n];m_values new TValueStorage[n];int i 0;foreach(var kvp in m_dict){m_keys[i] kvp.Key;SetValue(m_values, i, kvp.Value);i;}}#region IDictionaryTKey, TValuepublic ICollectionTKey Keys { get { return ((IDictionaryTKey, TValue)m_dict).Keys; } }public ICollectionTValue Values { get { return ((IDictionaryTKey, TValue)m_dict).Values; } }public int Count { get { return ((IDictionaryTKey, TValue)m_dict).Count; } }public bool IsReadOnly { get { return ((IDictionaryTKey, TValue)m_dict).IsReadOnly; } }public TValue this[TKey key]{get { return ((IDictionaryTKey, TValue)m_dict)[key]; }set { ((IDictionaryTKey, TValue)m_dict)[key] value; }}public void Add(TKey key, TValue value){((IDictionaryTKey, TValue)m_dict).Add(key, value);}public bool ContainsKey(TKey key){return ((IDictionaryTKey, TValue)m_dict).ContainsKey(key);}public bool Remove(TKey key){return ((IDictionaryTKey, TValue)m_dict).Remove(key);}public bool TryGetValue(TKey key, out TValue value){return ((IDictionaryTKey, TValue)m_dict).TryGetValue(key, out value);}public void Add(KeyValuePairTKey, TValue item){((IDictionaryTKey, TValue)m_dict).Add(item);}public void Clear(){((IDictionaryTKey, TValue)m_dict).Clear();}public bool Contains(KeyValuePairTKey, TValue item){return ((IDictionaryTKey, TValue)m_dict).Contains(item);}public void CopyTo(KeyValuePairTKey, TValue[] array, int arrayIndex){((IDictionaryTKey, TValue)m_dict).CopyTo(array, arrayIndex);}public bool Remove(KeyValuePairTKey, TValue item){return ((IDictionaryTKey, TValue)m_dict).Remove(item);}public IEnumeratorKeyValuePairTKey, TValue GetEnumerator(){return ((IDictionaryTKey, TValue)m_dict).GetEnumerator();}IEnumerator IEnumerable.GetEnumerator(){return ((IDictionaryTKey, TValue)m_dict).GetEnumerator();}#endregion#region IDictionarypublic bool IsFixedSize { get { return ((IDictionary)m_dict).IsFixedSize; } }ICollection IDictionary.Keys { get { return ((IDictionary)m_dict).Keys; } }ICollection IDictionary.Values { get { return ((IDictionary)m_dict).Values; } }public bool IsSynchronized { get { return ((IDictionary)m_dict).IsSynchronized; } }public object SyncRoot { get { return ((IDictionary)m_dict).SyncRoot; } }public object this[object key]{get { return ((IDictionary)m_dict)[key]; }set { ((IDictionary)m_dict)[key] value; }}public void Add(object key, object value){((IDictionary)m_dict).Add(key, value);}public bool Contains(object key){return ((IDictionary)m_dict).Contains(key);}IDictionaryEnumerator IDictionary.GetEnumerator(){return ((IDictionary)m_dict).GetEnumerator();}public void Remove(object key){((IDictionary)m_dict).Remove(key);}public void CopyTo(Array array, int index){((IDictionary)m_dict).CopyTo(array, index);}#endregion#region IDeserializationCallbackpublic void OnDeserialization(object sender){((IDeserializationCallback)m_dict).OnDeserialization(sender);}#endregion#region ISerializableprotected SerializableDictionaryBase(SerializationInfo info, StreamingContext context) {m_dict new DictionaryTKey, TValue(info, context);}public void GetObjectData(SerializationInfo info, StreamingContext context){((ISerializable)m_dict).GetObjectData(info, context);}#endregion
}public static class SerializableDictionary
{public class StorageT : SerializableDictionaryBase.Storage{public T data;}
}[Serializable]
public class SerializableDictionaryTKey, TValue : SerializableDictionaryBaseTKey, TValue, TValue
{public SerializableDictionary() {}public SerializableDictionary(IDictionaryTKey, TValue dict) : base(dict) {}protected SerializableDictionary(SerializationInfo info, StreamingContext context) : base(info, context) {}protected override TValue GetValue(TValue[] storage, int i){return storage[i];}protected override void SetValue(TValue[] storage, int i, TValue value){storage[i] value;}
}[Serializable]
public class SerializableDictionaryTKey, TValue, TValueStorage : SerializableDictionaryBaseTKey, TValue, TValueStorage where TValueStorage : SerializableDictionary.StorageTValue, new()
{public SerializableDictionary() {}public SerializableDictionary(IDictionaryTKey, TValue dict) : base(dict) {}protected SerializableDictionary(SerializationInfo info, StreamingContext context) : base(info, context) {}protected override TValue GetValue(TValueStorage[] storage, int i){return storage[i].data;}protected override void SetValue(TValueStorage[] storage, int i, TValue value){storage[i] new TValueStorage();storage[i].data value;}
}普通字典简单的使用
public class SerializedTest : MonoBehaviour {//普通字典public Dictionarystring, string dictionary;private void Start() {//实例化字典dictionary new Dictionarystring, string();//添加键值对dictionary.Add(name1, 小明);dictionary[name2] 小红;//检查是否包含指定的键string key name1;Debug.Log($是否包含键为{key}{dictionary.ContainsKey(key)});//检查是否包含指定的值string value 小红;Debug.Log($是否包含值为{value}{dictionary.ContainsValue(value)});//获取指定键的值Debug.Log($获取键为name2的值{dictionary[name2]});//移除键值对dictionary.Remove(name1);//获取键值对数量Debug.Log($获取键值对数量{dictionary.Count});//清空字典dictionary.Clear();}
}结果
可序列化字典简单的使用
和普通字典的使用方法一样只需要把Dictionary换成SerializableDictionary并且使用时不需要先实例化了
public class SerializedTest : MonoBehaviour {//可序列化字典public SerializableDictionarystring, string serializableDictionary;private void Start() {//添加键值对serializableDictionary.Add(name1, 小明);serializableDictionary[name2] 小红;//检查是否包含指定的键string key name1;Debug.Log($是否包含键为{key}{serializableDictionary.ContainsKey(key)});//获取指定键的值Debug.Log($获取键为name2的值{serializableDictionary[name2]});//移除键值对serializableDictionary.Remove(name1);//获取键值对数量Debug.Log($获取键值对数量{serializableDictionary.Count});//清空字典//serializableDictionary.Clear();}
}结果 运行时在挂载的脚本上也可以直接显示字典的值
二、序列化场景
正常我们都是按场景名称或者索引去跟踪我们的场景吗这里其实有一个更好的方法之后在所有的项目中我们都可以去使用它
灵感来源于一篇Unity论坛的SceneField代码 https://discussions.unity.com/t/inspector-field-for-scene-asset/40763 解释这是代码通过使用SceneField类和SceneFieldPropertyDrawer属性绘制器开发者可以在自定义的脚本中方便地引用和管理场景对象并在Inspector面板中进行编辑和选择操作。这对于需要频繁切换场景或者处理多个场景的情况非常有用。
新增SerializableScene.cs脚本如下
using UnityEngine;#if UNITY_EDITOR
using UnityEditor;
#endif[System.Serializable]
public class SerializableScene
{[SerializeField]private Object m_SceneAsset;[SerializeField]private string m_SceneName ;public string SceneName{get { return m_SceneName; }}// 使其与现有的Unity方法LoadLevel / LoadScene兼容public static implicit operator string(SerializableScene sceneField){return sceneField.SceneName;}
}#if UNITY_EDITOR
[CustomPropertyDrawer(typeof(SerializableScene))]
public class SceneFieldPropertyDrawer : PropertyDrawer
{public override void OnGUI(Rect _position, SerializedProperty _property, GUIContent _label){EditorGUI.BeginProperty(_position, GUIContent.none, _property);SerializedProperty sceneAsset _property.FindPropertyRelative(m_SceneAsset);SerializedProperty sceneName _property.FindPropertyRelative(m_SceneName);_position EditorGUI.PrefixLabel(_position, GUIUtility.GetControlID(FocusType.Passive), _label);if (sceneAsset ! null){// 显示场景选择器让用户选择一个场景sceneAsset.objectReferenceValue EditorGUI.ObjectField(_position, sceneAsset.objectReferenceValue, typeof(SceneAsset), false);// 如果已经选择了场景则将场景名称保存在场景名称变量中if (sceneAsset.objectReferenceValue ! null){sceneName.stringValue (sceneAsset.objectReferenceValue as SceneAsset).name;}}EditorGUI.EndProperty();}
}
#endif测试调用
public class SerializedTest : MonoBehaviour {//可序列化场景public SerializableScene scene1;public SerializableScene scene2;private void Start() {SceneManager.LoadScene(scene1);//跳转场景}
}绑定数据
三、序列化vector
新增SerializedVector.cs代码
using System;
using UnityEngine;/// summary
/// 定义一个可序列化的Vector3结构
/// /summary
[Serializable]
public struct SerializedVector3 : IEquatableSerializedVector3
{public float x, y, z; // 向量的x、y、z分量// 构造函数用于初始化向量public SerializedVector3(float x, float y, float z){this.x x;this.y y;this.z z;}// 判断当前向量是否与其他向量相等public bool Equals(SerializedVector3 other){return this.x other.x this.y other.y this.z other.z;}// 重写ToString方法返回向量的字符串表示public override string ToString(){return $({x},{y},{z});}// 重写GetHashCode方法生成哈希值public override int GetHashCode(){return x.GetHashCode() ^ (y.GetHashCode() 2) ^ (z.GetHashCode() 2);}// 隐式转换SerializedVector3 - Vector3public static implicit operator SerializedVector3(Vector3 vector3){return new SerializedVector3(vector3.x, vector3.y, vector3.z);}// 隐式转换Vector3 - SerializedVector3public static implicit operator Vector3(SerializedVector3 vector3){return new Vector3(vector3.x, vector3.y, vector3.z);}// 隐式转换SerializedVector3 - Vector3Intpublic static implicit operator SerializedVector3(Vector3Int vector3){return new SerializedVector3(vector3.x, vector3.y, vector3.z);}// 隐式转换Vector3Int - SerializedVector3public static implicit operator Vector3Int(SerializedVector3 vector3){return new Vector3Int((int)vector3.x, (int)vector3.y, (int)vector3.z);}
}/// summary
/// 定义一个可序列化的Vector2结构
/// /summary
[Serializable]
public struct SerializedVector2 : IEquatableSerializedVector2
{public float x, y; // 向量的x、y分量// 构造函数用于初始化向量public SerializedVector2(float x, float y){this.x x;this.y y;}// 判断当前向量是否与其他向量相等public bool Equals(SerializedVector2 other){return this.x other.x this.y other.y;}// 重写ToString方法返回向量的字符串表示public override string ToString(){return $({x},{y});}// 重写GetHashCode方法生成哈希值public override int GetHashCode(){return x.GetHashCode() ^ (y.GetHashCode() 2);}// 隐式转换SerializedVector2 - Vector2public static implicit operator SerializedVector2(Vector2 vector2){return new SerializedVector2(vector2.x, vector2.y);}// 隐式转换Vector2 - SerializedVector2public static implicit operator Vector2(SerializedVector2 vector2){return new Vector2(vector2.x, vector2.y);}// 隐式转换SerializedVector2 - Vector2Intpublic static implicit operator SerializedVector2(Vector2Int vector2){return new SerializedVector2(vector2.x, vector2.y);}// 隐式转换Vector2Int - SerializedVector2public static implicit operator Vector2Int(SerializedVector2 vector2){return new Vector2Int((int)vector2.x, (int)vector2.y);}
}// 扩展方法类用于转换向量
public static class SerializedVectorExtensions
{// 将SerializedVector3转换为Vector3public static Vector3 ConverToVector3(this SerializedVector3 sv3){return new Vector3(sv3.x, sv3.y, sv3.z);}// 将Vector3转换为SerializedVector3public static SerializedVector3 ConverToSVector3(this Vector3 v3){return new SerializedVector3(v3.x, v3.y, v3.z);}// 将SerializedVector3转换为Vector3Intpublic static Vector3Int ConverToVector3Int(this SerializedVector3 sv3){return new Vector3Int((int)sv3.x, (int)sv3.y, (int)sv3.z);}// 将Vector3Int转换为SerializedVector3public static SerializedVector3 ConverToSVector3Int(this Vector3Int v3){return new SerializedVector3(v3.x, v3.y, v3.z);}// 将SerializedVector2转换为Vector2public static Vector2 ConverToSVector2(this SerializedVector2 sv2){return new Vector2(sv2.x, sv2.y);}// 将SerializedVector2转换为Vector2Intpublic static Vector2Int ConverToVector2Int(this SerializedVector2 sv2){return new Vector2Int((int)sv2.x, (int)sv2.y);}// 将Vector2转换为SerializedVector2public static SerializedVector2 ConverToSVector2(this Vector2 v2){return new SerializedVector2(v2.x, v2.y);}// 将Vector2Int转换为SerializedVector2public static SerializedVector2 ConverToSVector2(this Vector2Int v2){return new SerializedVector2(v2.x, v2.y);}
}测试调用
//普通Vector
public Vector3 vector3;
public Vector2 vector2;
//可序列化Vector
public SerializedVector3 serializedVector3;
public SerializedVector2 serializedVector2;//Vector3和SerializedVector3可以随意转换
Debug.Log(vector3);
vector3 serializedVector3;
Debug.Log(vector3);
serializedVector3 Vector3.zero;
Debug.Log(serializedVector3);配置 结果
四、序列化color
新增SerializableColor.cs
using UnityEngine;
using System;/// summary
/// 可序列化的颜色结构
/// /summary
[Serializable]
public struct SerializedColor
{public float r, g, b, a; // 颜色的红、绿、蓝和透明度分量// 构造函数用于初始化颜色public SerializedColor(float r, float g, float b, float a){this.r r; // 红色分量this.g g; // 绿色分量this.b b; // 蓝色分量this.a a; // 透明度分量}// 重写ToString方法返回颜色的字符串表示public override string ToString(){return $({r},{g},{b},{a}); // 格式化输出颜色分量}// 重写GetHashCode方法返回颜色的哈希值public override int GetHashCode(){return this.ConverToUnityColor().GetHashCode(); // 使用Unity的颜色哈希值}// 隐式转换Color - SerializedColorpublic static implicit operator SerializedColor(Color color){return new SerializedColor(color.r, color.g, color.b, color.a); // 从Unity的Color转换为SerializedColor}// 隐式转换SerializedColor - Colorpublic static implicit operator Color(SerializedColor color){return new Color(color.r, color.g, color.b, color.a); // 从SerializedColor转换为Unity的Color}
}/// summary
/// 颜色序列化扩展方法类
/// /summary
public static class Serialization_ColorExtensions
{// 将SerializedColor转换为Unity的Colorpublic static Color ConverToUnityColor(this SerializedColor color){return new Color(color.r, color.g, color.b, color.a); // 创建并返回Unity的Color}// 将Unity的Color转换为SerializedColorpublic static SerializedColor ConverToSerializationColor(this Color color){return new SerializedColor(color.r, color.g, color.b, color.a); // 创建并返回SerializedColor}
}测试调用
//颜色
public Color color;
//可序列化的颜色
public SerializedColor serializedColor;color new Color(1.0f, 0.5f, 0.0f, 1.0f);
Debug.Log(color);
serializedColor new SerializedColor(0.0f, 1.0f, 0.0f, 1.0f);
Debug.Log(serializedColor);
color serializedColor;
Debug.Log(color);配置 五、序列化旋转Quaternion
新增SerializedQuaternion.cs这个其实和vector序列号类似
using System;
using UnityEngine;/// summary
/// 定义一个可序列化的Quaternion结构
/// /summary
[Serializable]
public struct SerializedQuaternion : IEquatableSerializedQuaternion
{public float x, y, z, w; // 四元数的x、y、z、w分量// 构造函数用于初始化四元数public SerializedQuaternion(float x, float y, float z, float w){this.x x;this.y y;this.z z;this.w w;}// 判断当前四元数是否与其他四元数相等public bool Equals(SerializedQuaternion other){return this.x other.x this.y other.y this.z other.z this.w other.w;}// 重写ToString方法返回四元数的字符串表示public override string ToString(){return $({x}, {y}, {z}, {w});}// 重写GetHashCode方法生成四元数的哈希值public override int GetHashCode(){return x.GetHashCode() ^ (y.GetHashCode() 2) ^ (z.GetHashCode() 2) ^ (w.GetHashCode() 1);}// 隐式转换从Unity的Quaternion类型转换为SerializedQuaternionpublic static implicit operator SerializedQuaternion(Quaternion quaternion){return new SerializedQuaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);}// 隐式转换从SerializedQuaternion转换为Unity的Quaternion类型public static implicit operator Quaternion(SerializedQuaternion quaternion){return new Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w);}
}// 扩展方法类用于转换四元数
public static class SerializedQuaternionExtensions
{// 将SerializedQuaternion转换为Unity的Quaternion类型public static Quaternion ConvertToQuaternion(this SerializedQuaternion sq){return new Quaternion(sq.x, sq.y, sq.z, sq.w);}// 将Unity的Quaternion类型转换为SerializedQuaternionpublic static SerializedQuaternion ConvertToSQuaternion(this Quaternion q){return new SerializedQuaternion(q.x, q.y, q.z, q.w);}
}测试调用
//旋转
public Quaternion quaternion;
//可序列化旋转
public SerializedQuaternion serializedQuaternion;// 定义一个欧拉角绕X、Y、Z轴的旋转
Vector3 eulerAngles new Vector3(30f, 45f, 60f);
// 将欧拉角转换为四元数
quaternion Quaternion.Euler(eulerAngles);
// 将四元数转换为欧拉角
eulerAngles quaternion.eulerAngles;
Debug.Log(eulerAngles);//直接赋值
serializedQuaternion Quaternion.Euler(eulerAngles);
serializedQuaternion quaternion;//互相转换
serializedQuaternion quaternion.ConvertToSQuaternion();
quaternion serializedQuaternion.ConvertToQuaternion();完结
赠人玫瑰手有余香如果文章内容对你有所帮助请不要吝啬你的点赞评论和关注你的每一次支持都是我不断创作的最大动力。当然如果你发现了文章中存在错误或者有更好的解决方法也欢迎评论私信告诉我哦
好了我是向宇https://xiangyu.blog.csdn.net
一位在小公司默默奋斗的开发者闲暇之余边学习边记录分享站在巨人的肩膀上通过学习前辈们的经验总是会给我很多帮助和启发如果你遇到任何问题也欢迎你评论私信或者加群找我 虽然有些问题我也不一定会但是我会查阅各方资料争取给出最好的建议希望可以帮助更多想学编程的人共勉~
