创建于 2024年3月3日 07:29:36 · 约36,713字
很多都是参数介绍，看的时候打开Unity对着面板看一眼
工程文件夹都是干什么的，以及需要版本管理的文件夹。初始化推送后，拷贝项目到新电脑并拉取即可同步。官方推荐的管理github/Unity.gitignore
在一个unity项目中，不要把 .sln / .csproj 加入 git，在任何电脑、任何平台，它们都会被 Unity 自动重新生成
C
.
├── Assets // 美术脚本主要工程文件，只要它不丢，其余文件删除后打开Unity会自动重建，加入Git
│ ├── ArtRes // 原始美术资源，可不加入Git！
│ ├── UsedArtRes // 从ArtRes中拖出使用资源避免直接修改原始资源
│ └── other_folder...
├── Library // 库文件夹PackageCache中的包为Unity自动下载，缺失时重新打开项目会自动恢复
├── Logs // 日志文件夹，记录特殊运行信息
├── Packages // 包配置信息，建议加入Git
├── ProjectSettings // 工程设置信息，删后重建会丢失自定义配置，必须加入Git
├── Temp
├── UserSettings // 用户设置，建议加入Git
├── AssetBundles
├── Assembly-CSharp-Editor.csproj
├── Assembly-CSharp.csproj
├── Client.sln
└── Client.sln.DotSettings // vscode的个人配置，有的话记得不要跟踪.idea/
.vscode/
.vs/
.DS_Store
Thumbs.db
Logs/
obj
Temp
Library
AssetsBundles
Assembly-CSharp.csproj
Assembly-CSharp-Editor.csproj
Client.sln
Client.sln.DotSettings.vscode/settings.json配置
json
{"files.exclude": { "**/*.meta": true}}重要的几个面板
Scene中常用快捷键
Scene的工具栏中比较重要的几个
shading mode，默认shader渲染，可以切换网格/混合渲染，后面的是2D视图 声 光 特效 辅助线开关，摄像机调整。
Gizmos是用来设置Scene中不同类型的GameObject图标的, 一般这个工具栏的东西都不用特殊调整。
轴向以屏幕为参照物:
Game界面⏯是逐帧播放，status是渲染详细信息
project的更多选项(三个点)可以切换界面显示方式，可以选择两列显示,Asset alt缩放到最小按照行显示
Inspector面板，可以设置在场景设置中的图标，Layer系统和Tag系统可以给对象分类，可以在更多中设置Debug显示更多信息方便调试
注意 Inspector设置的值会覆盖C#脚本的初始值
顶栏菜单额外嘱咐的
对象关系
transform是最基本的位置信息。物体拿到手transform先归零好判断位置，子对象的transform是针对父对象来说的，会根据父对象变化而变化。
unity的基本单位是米，体积是基本单位就是立方米，质量的基本单位是kg 在 Unity 外部创建模型规范 - Unity 手册
[ ⚠️Warning ]
游戏是数据的一种体现，利用程序把美术和数据组织起来
无论是美术还是自己拼模型，模型的正方向一定是Z轴的正方向，也就是垂直纸面向内。和开发者的目光齐平，缩放单位要注意！
骨骼-非必须，有动作的模型才需要
网格面片-必须，决定了模型的轮廓
贴图-必须，决定了模型的颜色效果
官方推荐使用fbx格式的模型文件其它格式虽然支持，但是不推荐。[.fbx .dae .3ds .dxf .obj]
导入完之后看看他有没有做好了预设体，别傻乎乎自己再去重复劳动
最好使用空物体作为总的父对象，容易控制缩放
美术给的资源最好不要直接改，拖一份复制到工作文件夹。
一般和模型搭配的武器等，会预留一个节点拖上去之后重置位置就应该是匹配好的
拼UI的时候，一般会给一张美术底图，垫在底下照着拼。
Unity利用反射获取 场景中(Scene.unity) 的所有自定义的 GameObject和挂载其上的脚本，所有的特征都是GameObject +Component呈现出来的
场景的本质是记录了 GameObject和关联的信息存起来的文件，后缀是Scene.unity 把两个场景都拖到Hierachy中可以让场景叠加显示，一般只有互相copy的时候才这么干
public的属性能在inspector上编辑，加上[HideInspector]就隐藏了；private的和protected不能被显示，加上[SerializeField]也可以被显示
自定义的结构体和类对象使用[System.Serializable]就可以被显示了。
已经挂到 GameObject修改了脚本的值对象上挂载的那个不会被更改，手动或者重挂，也可以运行过程中可以用Inspector->copy和paste脚本，但是一般不会这么做
departure的方法如果硬要用会报错，但是传第二个参数为false就可以继续用虽然不推荐
untiy支持的宏（可恶要变成宏孩儿了吗
[ 📌Tip ]
其实直接拖对象有点破坏面向对象思想，尤其是多人合作依赖关系容易变成一坨，而且从外边拖进来的你还没法从代码直接点过去
代码Find之后再改效率不如拖高，因为不用查找(其实查找也查找不了几个最多在自己的子去查找)
在Editor绑定的好处是程序做完了，给个毛坯给策划，让他们自己去精装，把体力活交给策划，程序只负责实现功能就行了。
[Header("分组说明")][Tooltip("说明内容")][Space()][Range(最小值, 最大值)][Multiline(4)][TextArea(3, 4)][ContextMenuItem("右键显示啥名", "function")][ContextMenu("测试函数")]Perfab的存储规则和Scene是一样的，C#脚本组件任何东西都一块保存。
在Inspector面板中可以把当前选中的预设体的更改保存到预制体或者放弃更改，重新拖进Assets中是覆盖。如果删除或者修改已有预设体，那所有的预设体都会被修改
在场景中直接unpack prefab然后编辑，再拖进Assets搞个新的。把未修改预设体拖回去是复制一个一模一样的预制体。如果预设体被删除但是场景中已经使用了，就会变红提示，不想要就直接unpack。
prefab的unpack和unpack cmoplete是选择是否解开子物体的预制体(如果子物体是prefab的话)
[ ⚠️Warning ]
在Unity中类名和文件名必须一致，因为是通过反射字符串去获取类和自定义组件的
自己写的脚本实际上也是组件(Component)继承了MonoBehaviour的都是组件。 一个脚本可以挂在同一个对象多次，也就会创建多个脚本对象，可以脚本中开[DisallowMultipleComponent]特性就不能一挂多了。其实本质是拖过去的时候通过反射获取文件的名字，然后根据名字字符串拿到对应类
MonoBehaviour的继承链是MonoBehaviour <- Behaviour <- Component ，继承Component的就是组件。当然可以继续继承
集成了MonoBehaviour的类只能挂载不能new，不能自定构造函数。 在Inspector->ExecutionOrder中其实可以规定执行顺序的，默认顺序是不确定的，Editor/Data/Resources/ScriptTemplates可以修改默认脚本模板，这俩一般不用特意改。
人眼舒适放松时候看电影可视帧数是24fps而动态交互类的一般是60fps，游戏卡顿的原因就是一帧内的计算量过大没法处理完所有的游戏逻辑。
生命周期函数(是按下面顺序执行的！！！！)：
生命周期函数是支持继承和多态的， 子类继承类之后进行override就可以。
但是生命周期函数却不是从基类中override过来的
如果生命周期无法满足需求那就需要使用任务调度，时间任务调度函数Invoke InvokeRepeating CancelInvoke (参数都简单易懂
Csharp
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class TestLifeCycle : MonoBehaviour
{
void Awake() // 首次被产生或者从不可见变为可见的前(核心就是首次启用)执行一次,再次启用就不会执行，例如查找资源用
{
Debug.Log("I'm awake");
}
private void OnEnable() // 每次启用前的函数，可以用来Fetch资源
{
Debug.Log("I'm Ready!");
}
void Start() // GameObject加载完毕后所有的Awake执行完的第一帧执行一次
{
Debug.Log("I'm Start First Time!");
}
private float timedelta = 0.2f;
void FixedUpdate()
{
Debug.Log($"every {timedelta} second Update once");
} // Update is called once per frame
void Update()
{
Debug.Log("frame start");
}
void LateUpdate() // 每帧之后
{
Debug.Log("frame end");
}
void OnDisable()
{
Debug.Log("I'm Disabled");
}
void OnDestroy()
{
Debug.Log("I'm Destory");
}
}运行结果
[21:35:31] I'm awake
[21:35:31] I'm Ready!
[21:35:31] Object start successfully Complete
[21:35:44] every 0.2 second Update once
[21:35:44] frame start
[21:35:44] frame end
[21:35:40] be Invoked
[21:35:35] be Invoked Hello, World!
[21:35:42] Invoke is CanceledMonoBehaviour内置的重要变量，它能获得什么属性去IDE里看，稍微列一下最常用的，不赘述。this不是依附的GameObject
Component中声明的(this.)gameObject可以直接使用，这个对象就是脚本挂载的对象。transform是获取位置信息
如果要获得其他的GameObject挂载脚本的对象，声明一个对应类然后把对象拖过去就可以。获得GameObject上的其他的 Component有一系列方法，参考一下，最常用的是根据泛型获得
Csharp
void Start()
{
print(gameObject.name);// 挂载GameObject的名字
print(this.transform.position);// 对象的位置
print(this.transform.eulerAngles);// 旋转欧拉角
print(this.transform.lossyScale);// 缩放
print(this.enabled);// 脚本是否被启用
// 获得其他组件
GTest g1 = this.GetComponent("GTest") as GTest; // 通过名字获得
GTest g2 = this.GetComponent(typeof(GTest)) as GTest;// 通过类型获得
GTest g3 = this.GetComponent<GTest>(); // ⭐️通过泛型获得
GTest[] g4 = this.GetComponents<GTest>(); // 获得多个，但是无法确定是哪一个
GTest[] g5 = GetComponentsInChildren<GTest>(true); // 递归查找所有子对象包括自己的组件,参数代表要不要查找未激活的对象的
GTest[] g6 = GetComponentsInParent<GTest>(true); // 递归查找所有父对象包括自己的组件,参数代表要不要查找未激活的对象的
GTest gt;
bool exists = TryGetComponent<GTest>(out gt); // 尝试获得，返回值是bool
}[ ⚡️Danger ] 变量的构造使用
在MonoBehaviour的子类中，变量声明是早于所有的生命周期函数的，所以基本不会在变量声明里面赋值引用类型，因为有可能使用未声明的变量。
所以赋值都是放到声明周期函数中。
Unity中的脚本加载顺序是随机的，同时在场景上挂载两个你不能控制哪个先运行，所以如果有变量的依赖可以使用事件通知或者协程异步的方式去加载。
GameObject的一些静态方法。
可以直接申请一个对象然后拖进去(最常用的)，或者使用下面的方法查找
常用的属性和查找对象是找不到incativate的对象的，如果场景中多个满足条件的对象，则无法确定是哪个
动态创建对象，先拖过去获取 GameObject然后使用GameObject.Instantiate(obj)初始化新的，名字会带(Clone)GameObject.Destory(obj)可以动态删除对象甚至可以删除附加的脚本，实际上是下一帧移除的，立即从内存中移除需要使用GameObject.DestroyImmediate(mycube);DonotDestoryOnLoad(obj)只能作用于根层级
这俩函数实际上有很多重载方法。
默认切换场景的时候之前的都被移除了，如果不想某对象换场景被移除，使用GameObject.DontDestroyOnLoad(this.gameObject);最常用的就是传自己
Csharp
public class L4Script : MonoBehaviour
{
private GameObject mycube;
public GameObject find;
public GameObject[] finds;
public GameObject dynamicObj;
public GameObject dynamicObjClone;
void Start()
{
Debug.Log(gameObject.name);
Debug.Log(gameObject.isStatic);
Debug.Log(gameObject.activeSelf);
Debug.Log(gameObject.layer); // 这返回的其实是个整数
Debug.Log(gameObject.tag);
Debug.Log(gameObject.transform.position);
mycube=GameObject.CreatePrimitive(PrimitiveType.Cube); // 和右键点击创建一样，也能创建其他类型
mycube.name = "xx";
mycube.tag = "Monster";
// 查找 是找不到失活对象，如果场景中多个满足条件的对象，则无法确定是哪个
find = GameObject.Find("xx");// 需要遍历所有对象，运行效率比较低 一般不这么找
find = transform.Find("xy"); // 只寻找自己的子对象，在子对象和坐标那有详细的
find = GameObject.FindWithTag("Monster"); // 一样FindGameObjectWithTag
finds = GameObject.FindGameObjectsWithTag("Monsters"); // 只有通过tag查找能找到多个对象
L4Script l4 = FindObjectOfType<L4Script>(); // UnityEngine.Object的查找更费劲，不仅遍历对象还遍历脚本
dynamicObjClone=GameObject.Instantiate(dynamicObj); // 获取到对象然后初始化的方法
GameObject.Destroy(dynamicObjClone,5); // 五秒后删除
GameObject.Destroy(this);// 甚至可以删除附加的脚本
GameObject.DestroyImmediate(mycube);// 立即从内存中移除，更可能会卡顿
GameObject.DontDestroyOnLoad(this.gameObject);// 最常用的就是传自己
}
}当你new GameObject的时候实际上就创建了一个 空物体 甚至创建之后可以挂脚本。甚至脚本中套娃创建都能执行
动态的为对象添加组件(脚本也是组件)，拿到组件就可以更改组件的属性，从而控制行为。
Csharp
void Start()
{
GameObject ng1 = new GameObject("我创建的新的空对象"); // 创建了一个新的 空对象
ng1.name = "我创建的新的空对象1";
GameObject ng2 = new GameObject("我创建的新的空对象",typeof(GTest));
GTest gt1=ng1.AddComponent(typeof(GTest)) as GTest; // 动态添加组件
GTest gt2=ng1.AddComponent<GTest>(); // 使用泛型动态添加组件更常用
Debug.Log("success init");
if (find.tag == "Monster")// 标签比较
{
bool TagEqual = find.CompareTag("Monster"); // 和上面的条件一样
print($"Tag is Monster{TagEqual}");
}
find.SetActive(false); // 激活函数不多说
find.SetActive(true);
}[ ℹ️Info ] 不常用的报个菜名
this.gameObject.SendMessage("TestFun");通过反射去动态调用这个 GameObject脚本上的函数this.gameobject.BroadcastMessage("func");广播行为 让自己和自己的子对象执行this.gameobject.SendMessageupwards("func");向父对象和自己发送消息并执行
每个GameObject都有这两个属性，可以在Inspector面板进行编辑，可以给Layer起名字。
Csharp
obj.layer = LayerMask.NameToLayer("LayerA"); //给物体设置层
int l=LayerMask.NameToLayer("UI"); // LayerToName
Physics.OverlapBox(Vector3.zero,Vector3.one, Quaternion.AngleAxis(45,Vector3.up),
1<<LayerMask.NameToLayer("UI") | 1<<LayerMask.NameToLayer("Default") // 检测UI和Default层0000 0000 0000 0010 0001
);注意此处数字层的含义，这个int代表的是此层的二进制哪一位是1,unity一共32层，如果你要检测第五层和第1层，则需要如上述代码一样，将层数二进制左移对应数，然后两层进行或操作，这样用一个二进制就可以表示你想检测的所有层，unity内部会进行与操作再去检测
SortingLayers相当于PS中层的概念，每个Object属于哪个层，最下面的从层最靠前
在编辑模式下，是不限帧率的。Time用于游戏中参与位移、记时、时间暂停等，Mathf和Random都是Unity命名空间下的不是C#自带的Random.Range(start,end) 传浮点返浮点，传整数返整数；整数有头没尾，浮点有头有尾。
Csharp
void Update()
{
Time.timeScale = 1.0f; // 缩放倍数0的时候停止
print(Time.deltaTime); // 最近两帧间隔多长时间，稳定应该是 (1/帧率)S，主要是用来计算位移的 路程=时间*速度
print(Time.unscaledDeltaTime);// 不受timeScale影响的帧间隔时间，如果希望游戏暂停了还跑的东西
print(Time.fixedTime);// 两个FixedUpdate的间隔时间
print(Time.fixedDeltaTime); // 物理帧间隔，受scale影响
print(Time.fixedUnscaledDeltaTime); // 物理帧间隔，不受scale影响
print(Time.frameCount);// 游戏到现在跑了多少帧了
print(Time.time);// 游戏开始到现在过了多少时间
// Random
Random.Range(start,end)
}Math是System中提供的数学类，而Mathf是unity提供的结构体，二次封装且多了一些游戏常用的，用他就行。
取整数 直接类型转换 和 Mathf.FloorToInt(9.6f)是向下取整，而CellToInt是向上取整。
Csharp
Mathf.PI
Mathf.Abs(-10) // 取绝对值
Mathf.CeilToInt(1.00001f)//向上取整 Mathf.FloorToInt(9.6f)//向下取整
// 钳制函数如果不超过区间就返回传入的数字，否则返回靠近的区间端点
Mathf.Clamp(10, 11, 20) Mathf.Max(1, 2)
Mathf.Min(1.1f, 0.4f)
Mathf.Pow(4, 2)// 一个数的n次幂
Mathf.RoundToInt(1.3f) // 四舍五入
Mathf.Sqrt(4) // 返回一个数的平方根
Mathf.IsPowerOfTwo(4)// 判断一个数是否是2的n次方
Mathf.Sign(0)// 判断正负数
// 每帧改变start的值按照极限逼近lim
start = Mathf.Lerp(start, 10, Time.deltaTime);
// 结果会线性跟随
time += Time.deltaTime;
result = Mathf.Lerp(start, 10, time);Lerp插值公式为result = start + (end - start) * t;其中t为速度系数，常用的两个调用方式取值如下两曲线，lim(每帧改变start)和线性(每帧改变t)
弧度rad即是PI/180，使用静态变量Rad2Deg = 57.29578f;，Deg2Rad = 0.017453292f;一乘即可和角度互相转换；Mathf.Sin(r)参数和返回值都是rad类型，可以传30*Mathf.Deg2Rad
Vector3是Unity内置的结构体，他不是类！默认值(0f,0f,0f)，初始化的时候传xy则z自动为0，默认的加减乘除就是对应坐标加减乘除，重载了哪些运算符点进去看。
Vector是Unity中的结构体，可用的有Vector2 Vector3 Vector4。
向量已经进行运算符的重载，使用B-A可以获得A指向B的向量，取反会三个方向都加负号，也就是指向反方向。
使用V.magnitude直接获得向量的模长和Vector3.Distance(Vector3.zero,V)一样，也就是三维空间中的距离Mathf.Sqrt(x^2+y^2+z^3)
向量除自己的模长可以归一化为单位向量，使用V.normalized获得，和V/V.magnitude一样
Csharp
Vector3.zero // (0, 0, 0) 零向量
Vector3.right // (1, 0, 0)
Vector3.left // (-1, 0, 0)
Vector3.forward // (0, 0, 1)这是Unity的正方向
Vector3.back // (0, 0, -1)
Vector3.up // (0, 1, 0)
Vector3.down // (0, -1, 0)
Vector3.Distance(v1,v2)// 计算两点之间的空间距离，和V.magnitude一样
V.normalized==V/V.magnitude // 归一化 true
float result=Vector3.Dot(A,B); // A•B点乘的用法
Vector3 V=Vector3.Cross(A,B) // A*B叉乘的用法点乘 获得的是对应坐标相乘再相加的一个标量，A•B的几何意义是B在A上的投影长度，因为AB是向量，所以可以用来判断AB的夹角>0锐角=0直角<0钝角。
可以大致判断物体的方位，物体面朝向是A然后另一个物体的坐标是B，此时使用A•B就可以大致判断方位
如果要做侦测是否在角度范围内,注意到Cosβ=A•B使用反三角函数直接算出来，但是其实可以调用Vector3.Angle(A,B)其实也使用点乘获得的
叉乘 每个纬度原来的数值不会参与运算即X=YaZb−ZaYb; Y=ZaXb−XaZb; Z=XaYb−YaXb;使用Vector3 V=Vector3.Cross(A,B)，新的向量V是AB的法向量，也是AB平面的法向量，若A在B的右侧 则法向量是垂直向上的反之则向下
假设向量 A 和 B 在 XZ 平面内，如果算出来Y>0则说明向量 B 在向量 A 的右侧反之在左侧，那就可以结合点乘判断物体距离角度和左右侧。
Lerp 插值运算，对两个坐标点进行插值运算，和Mathf的Lerp一样，只不过是三维的。
[ ⚠️Warning ] 注意线性插值瞬移问题
线性插值可以用来做一些摄像机的跟随移动这样的东西。
当线性插值t累加>=1的时候（如果 t>1它也会按 1.0计算），公式可以直接抵消，result=start+(end-start)*1 = end+O(t)，如果是向量Lerp则两个物体会直接重合起来没法分开了。
可以设置一些条件，让t和start位置重置一下避免这个问题。
球形插值 Vector3.Slerp(A.position,B.position,Time.deltaTime);不常用，可以让物体A呈弧线移动到位置B，比如模拟东升西落。
transform.position在是世界坐标的位置，而transform.localPosition是相对于父对象的坐标，也就是面板上的。虽然可以单独调用，修改的时候只能通过position属性不能单独改某个维度的坐标
注意transform.forward/up/right这三个是 GameObject自身的正方向，使用Vector3.forward/up/right是世界坐标正方向。使用transform.Translate()封装好的API移动
相对世界坐标角度transform.eulerAngles和相对父对象的角度(面板上是这个)transform.localEulerAngles角度的修改和坐标的修改差不多transform.lossyScale相对于世界坐标的缩放，不能修改(那为什么要提供？transform.localScale自己的缩放 没有提供API，只能自己慢慢每帧写transform.LookAt(Vector3.zero) 一直看向某个.点，传进某个 GameObject就会一直盯着看，重载了的也可以传position。
[ 📝Note ]
使用eulerAngles属性获得的始终是0-360度的角度，但是面板上是可以出现负数的，需要自己写一些逻辑转换角度
自身方向的偏转角是怎么算出来的？ #todo
Csharp
void Update()
{
// 每帧 移动 1/帧率*(0,0,1) 也就是每秒1单位(米)
transform.position += transform.forward * (Time.deltaTime * 1f);
// transform封装好的和上面一样，一般用它位移，参数控制相对于世界坐标还是自身坐标
// 注意这里就有排列组合了，以[自己or世界]坐标中心，偏移[自己or世界]朝向运动
transform.Translate(transform.up * (Time.deltaTime * 1f),Space.Self);
// 1. 相对于世界坐标系的z轴移动，始终是朝世界坐标系的z轴正方向移动
transform.Translate(Vector3.forward * (1 * Time.deltaTime), Space.World);
// 2. 相对于世界坐标的自己面朝向动，transform.forward会先转换为等效世界坐标系下的方向向量，然后始终朝自己的面朝向移动
transform.Translate(transform.forward * (1 * Time.deltaTime), Space.World);
// 3. 相对于自己的坐标系下的自己的面朝向量移动（一定不会这样让物体移动,因为Z轴偏转被算了两次
transform.Translate(transform.forward * (1 * Time.deltaTime), Space.Self);
// 4. 相对于自己的坐标系下的z轴正方向移动，始终朝自己的面朝向移动
transform.Translate(Vector3.forward * (1 * Time.deltaTime), Space.Self);
print(transform.eulerAngles);// 相对世界坐标角度
print(transform.localEulerAngles);// 相对父对象的角度，面板上是这个
transform.Rotate(new Vector3(0,10,0),Space.Self); // 绕自己坐标的Y轴转
transform.Rotate(new Vector3(0,10,0),Space.World); // 绕世界坐标的Y轴转
transform.Rotate(new Vector3(0,10,0),10*Time.deltaTime,Space.Self); // 重载 绕着哪个轴，转多少度，相对哪个坐标
transform.RotateAround(new Vector3(0,0,0),new Vector3(1,1,1),100*Time.deltaTime);// 相对于哪个点，哪个轴，旋转的角度
}相比于欧拉角可以提供Lerp。
空间中的角旋转都可以分解为绕XYZ三个互相垂直的三个旋转角组成的序列。最常用的旋转序列约定就是heading-pitch-bank(Y-X-Z)约定，transform.eulerAngles欧拉角的缺点是同一旋转的方式不唯一 万向节死锁(万向锁)。
在unity中将物体的X轴调到±90度会出现此现象，此时转动YZ都是绕Z转。
[ ⚠️Warning ] Gimbal lock问题
理解此问题的关键在于了解欧拉角旋转时的层级关系，当规定欧拉(2,1,3)时，其旋转层级关系可简单表述为y->x->z，即前者为后者的父层级。父层级的旋转会带动所有子层级旋转，而子层级的旋转不影响父层级的状态。
当x轴旋转时， 有概率使得z轴所在环与y轴所在环共面 ，此时即发生万向节死锁问题，导致z轴功能与y轴功能基本等效，即z轴失效。
此时若要旋转到需要的位置必须同时旋转3个轴，但这种旋转过程在实际空间中轨迹为弧线，不满足实际工程应用（比如摄像机转动会在球面上画个S弧而不是直线，运镜就很怪）
此时我们要用四元数解决这个问题，四元数包含一个标量和一个3D向量[w,(x,y,z)]代表了3D空间中的一个旋转量，在3D空间中，任意旋转都可以表示绕着某个轴v旋转一个角度w(轴-角 对)得到，因为只有一个轴所以避免了轴面重合
对于给定旋转，假设为绕着 N轴旋转 β 度，N轴为(x,y,z)，那可以构成四元数 Q=[cos(β/2),sin(β/2)N]具体展开 Q=[cos(β/2),sin(β/2)x,sin(β/2)y,sin(β/2)z]，第一个元素为四元数的实部，后面三个为虚部。
两个四元数相乘代表旋转四元数，四元数把角空间转换到180 ~ -180 此时位置的表示是唯一的，解决了 同一旋转表示不唯一 的问题。
单位四元数即[1,(0,0,0)] [-1,(0,0,0)]角度为0或者360度，没有旋转量的，使用Quaternion.identity获得，初始化对象的时候可以传入赋值
四元数同样提供了插值运算，即角度转向过程的插值，Quaternion.Lerp和Quaternion.Slerp。Lerp更快 但是如果旋转范围较大效果较差,建议首选Slerp进行插值运算。
注意LookRotation的运算，当A朝向B的时候，AB向量为轴，A可以绕此轴旋转自身，此时使用upwards规定Y轴也就是上的方向，三个角度就都就确定了，默认upwards是世界坐标的上方向
Csharp
void Start()
{
Vector3 fake_part=Mathf.Sin((60 / 2)*Mathf.Deg2Rad) * Vector3.right;
Quaternion q1 = new Quaternion(fake_part.x,fake_part.y,fake_part.z, (60 / 2)*Mathf.Deg2Rad);
Quaternion q2 = Quaternion.AngleAxis(60, Vector3.right); // 这种初始化常用，上面的不常用
Quaternion q3 = Quaternion.Euler(new Vector3(30,30,90)); // 欧拉角 转 四元数
q3.eulerAngles // 获得 四元数 的 欧拉角
Quaternion.identity; // 单位四元数
}
void Update()
{
transform.rotation*=Quaternion.AngleAxis(1, Vector3.up); // 四元数相乘，绕世界的Y轴转1度，每帧转
// Lerp和前面几个Lerp参数一样。
A.transform.rotation = Quaternion.Lerp(A.transform.rotation,target.transform.rotation,Time.deltaTime*0.3f);
B.transform.rotation = Quaternion.Slerp(B.transform.rotation,target.transform.rotation,Time.deltaTime*0.3f);
// 传入自己 A指向B的向量 可以计算出 A面朝B 需要的四元数，可以做到lookAt的效果，其实LookAt就是通过四元数做的。
A.transform.rotation=Quaternion.LookRotation(B.transform.position - A.transform.position, upwards:Vector3.up);
}两个四元数相乘的结果，相当于绕物体自己的坐标系旋转角叠加后的四元数， 注意四元数运算永远是使用物体本地坐标系进行旋转的
使用向量乘四元数的结果，相当于把此向量旋转对应四元数的旋转量后的向量， 注意此运算不满足交换律四元数必须在前
当把子对象拖到世界空间的时候，位置信息是加法，而缩放信息是乘法的；如果你再拖回去，那么就倒过来算一次(拖到GameObject下同理)。
坐标转换的时时候，会受到缩放影响，应该是除了scale
Csharp
void Start()
{
print(transform.parent.name);// 获取父对象
transform.parent = null; // 脱离父对象
GameObject F2 = GameObject.Find("F2");
transform.parent = F2.transform; // 绑定父对象
GameObject F3 = GameObject.Find("F3");
// 如果是False，那么会不经过计算而是直接绑定对象关系然后把原来的transform赋值过去
transform.SetParent(F3.transform,false);
transform.DetachChildren(); // 把自己下一层的物体都脱离，非递归
transform.Find("S2"); // transform下的Find是查找子对象，且失活的也能找到，非递归
print(transform.childCount);// 获得自己的子对象数量
transform.GetChild(0); // 通过下标索引获得子对象，这样就可以便利了
transform.IsChildOf(F2.transform); // 判断是不是传入对象子对象
transform.GetSiblingIndex(); // 获得自己的子对象编号，当然也有Set，Set传入溢出的时候就成为最后一个
transform.SetAsFirstSibling();// 设置为第一个，设置为最后一个
//世界转本地 #转换坐标系，可以大概判断相对位置
print(transform.InverseTransformPoint(Vector3.forward)); // 点转换
print(transform.InverseTransformDirection(Vector3.forward));// 单位向量转换 不受缩放影响
print(transform.InverseTransformVector(Vector3.forward));// 单位向量转换 这个会受缩放影响
// 本地转世界
print(transform.TransformPoint(Vector3.forward)); // ⭐️点转换(在单位的某方向放效果，可以直接转为世界然后创建)
print(transform.TransformDirection(Vector3.forward));// 单位向量转换 不受缩放影响
print(transform.TransformVector(Vector3.forward));// 单位向量转换 这个会受缩放影响
}Input类是内置的。键盘鼠标：屏幕的原点是左下角，所有的输入都是在Input类中管理的，一般用键盘的枚举在KeyCode，用Input.anyKeyDown和 Input.inputString捕获输入设置快捷键可以这么干 在 输入管理器 ProjectSettings-> InputManager设置默认轴输入Input.GetAxis，Unity中使用轴向来代表输入的方向，键鼠有四个常用的，不用我们手动处理按键和移动距离直接返回Float，移动越快值越大
这个方法返回的值是会缓冲逐渐加速 在 -1~0~1 之间，如果使用Input.GetAxisRaw可以获得不带加速度的
注意怎么处理组合键，如果组合键非常多，可以先用变量都捕获，然后下面自己加一堆逻辑判断。什么多点触控屏幕陀螺仪手柄，用到了再说
Csharp
Input.mousePosition; // 获得鼠标在屏幕上的位置
Input.GetMouseButtonDown(0) // 0左键1右键
Input.GetMouseButtonUp(0)
Input.GetMouseButton(0) // 持续按下
if (Input.mouseScrollDelta!=Vector2.zero){ // 鼠标滚动返回的是Vector2,正数向上滚反之可推
print(Input.mouseScrollDelta);// 滚动了才打印, 而且只变动Y值
}
Input.GetKeyDown(KeyCode.X) // 获得某个键的按下事件，只会触发一次
Input.GetKeyDown("b") // 也可以使用函数调用而不是枚举，大小写敏感，只接受小写字符串
Input.GetKeyUp(KeyCode.X) // 获得某个键的弹起事件
Input.GetKey(KeyCode.D) // 长按理论上是一帧一次,但是会帧率太高的话Unity中会优化,让触发频率降低
/* 处理组合键 */
bool isCtrlPressed = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl);
bool isCPressed = Input.GetKey(KeyCode.C);
if (isCtrlPressed && isCPressed)Debug.Log("Ctrl + C is pressed.");
/* 下面这俩搭配可以记录快捷键 */
Input.anyKeyDown // bool 是否有任意键按下
Input.anyKey // bool 是否有任意键长按
if (Input.anyKeyDown) print($"Pressed {Input.inputString}"); // 记录下捕获的，他只会捕获上一个
string[] strs = Input.GetJoystickNames(); // 获得所有手柄的名字
/* 使用默认轴输入 */
print(Input.GetAxis("Horizontal")); // 默认AD
print(Input.GetAxis("Vertical")); // 默认WS
print(Input.GetAxis("Mouse X")); // 鼠标水平
print(Input.GetAxis("Mouse Y")); // 鼠标竖直InputSystem官方搞的新的输入系统，2019后都推荐6之后是默认，要求.net4+，如果没有从PackageMannager安装。Edit->ProjectSettiing->Player->OtherSettings->Configuration->ActiveInputHandler中选择启用老的还是新的，选择之后重启生效。
Screen属性很简单就是宽高刷新率，注意设备分辨率和窗口的区别，自动旋转屏幕和运行时全屏也可以设置但是不太重要。
Csharp
void Start()
{
int w=Screen.width; // 软件画面窗口宽
int h=Screen.height; // 软件画面窗口高
print($"运行窗口(游戏内部帧缓冲) 高{h} 宽{w}");
Resolution r = Screen.currentResolution; // 物理显示器屏幕的宽高，如果是在编辑器里面是开发机器的屏幕，受系统设置影响
print($"执行程序的机器 高{r.height} 宽{r.width} 分辨率{r}");
Screen.sleepTimeout = SleepTimeout.NeverSleep; // 运行着的时候设备屏幕不休眠
Screen.SetResolution(1920, 1080, false); // 一般是在非移动设备上才设置分辨率
Screen.fullScreen = true;// 运行时全屏
Screen.fullScreenMode = FullScreenMode.Windowed;// 独占全屏 全屏窗口 最大化窗口 窗口模式 去枚举里面看
}[ 📝Note ] 坐标系汇总
世界坐标系-世界原点为中心
物体坐标系-建模时候确定,相对父对象的坐标
屏幕坐标系-使用Screen获得宽高原点在左下角
视口坐标系-和将屏幕坐标系百分比化，xy最大值都是1，对角为(1,1)
视口坐标和场景坐标转换API也在Camera中Camera.main.WorldToViewportPoint()
Camera可以设置的属性，非核心的随便看看就行了
[ 📌Tip ] 摄像机拖影
在 Depth Only 模式下，Unity 不会清除颜色缓冲区（Color Buffer），只会清除深度缓冲区（Depth Buffer）
这种模式通常用于多摄像机叠加渲染（如背景摄像机和UI摄像机分离）时，避免重复绘制背景
如果主摄像机或其他摄像机没有正确清理颜色缓冲区，可能会导致上一帧的画面残留，从而产生拖影
如果你有多个摄像机，请确保至少有一个摄像机（通常是主摄像机）的 Clear Flags 设置为 Skybox 或 Solid Color，以清理颜色缓冲区。
从代码中获取摄像机的场景中Camera的Tag为MainCamera的摄像机可以直接通过静态方法Camera.main获取，如果有多个(一般只有一个)随机获得一个
Inspector中的属性都可以用对象获得，摄像机提供的委托前妻不常用
注意 屏幕坐标<->世界坐标 转换Z轴值的问题
Csharp
void Start()
{
print(Camera.main.transform.position);
foreach (Camera c in Camera.allCameras) print(c);// 获得场景所有摄像机的数组
print(Camera.allCamerasCount); // 获得摄像机的计数
// 转换之后返回Vector3, xy就是屏幕坐标，z就是物体离屏幕远近
Camera.main.WorldToScreenPoint(transform.position);
// 屏幕转世界
Vector3 mousePos = Input.mousePosition;
// 如果不改变这个值，那么屏幕上的值是没有Z的，默认就是0
mousePos.z = 10; // 所以这里要改成10，这里的Z就是 距离摄像机横切面是多远
// 这样才不会一直是一个点，如果Z是0那么xy在三维空间中转换也是一直在一个点上
Camera.main.ScreenToWorldPoint(mousePos);
// 在特殊的时刻调用的委托
Camera.onPreCull += Func; // 比如这个就是 剔除遮挡 时候的委托
Camera.onPreRender += Func;
Camera.onPostRender += Func;
}Light相关，一眼能看出来的和不重要的属性就不放上去了。代码改改光晕强度什么的，照着面板改吧，其实提供的API不多
可以用点光源挑动和Holo大小模拟蜡烛，用方向光模拟白天黑夜轮换等
光源环境的设置在 菜单Window->Rendering->Lighting里面
在SkyboxMaterial中可以设置默认的天空盒(其实就是6个面的美术资源)，默认最亮的方向光代表太阳
也可以改Fog雾(吃性能) Flare耀斑 Holo光晕 效果等，接触不到的时候暂时不用看
碰撞产生的条件: 两个物体都有Collider且至少一个有Rigidbody 有了刚体Rigidbody物体才会受到力的作用
检测不到的常见原因: 不在同一Layer，trigger和碰撞没对好，Body Type: Kinematic脚本接管了
| 使用不同检测算法的物体 互相碰撞会用什么算法 | 无刚体碰撞盒 | Discrete (离散检测) | Continuous (连续检测) | Continuous Dynamic (连续动态检测) | Continuous Speculative (连续推测检测) |
|---|---|---|---|---|---|
| 无刚体碰撞盒 | 不检测碰撞 | Discrete | Continuous | Continuous | Continuous Speculative |
| Discrete | Discrete | Discrete | Discrete | Discrete | Continuous Speculative |
| Continuous | Continuous | Discrete | Discrete | Continuous | Continuous Speculative |
| Continuous Dynamic | Continuous | Discrete | Continuous | Continuous | Continuous Speculative |
| Continuous Speculative | Continuous Speculative | Continuous Speculative | Continuous Speculative | Continuous Speculative | Continuous Speculative |
Collider是描述物体体积的，有了Collider物体才有体积不会穿模。IsTrigger勾选会只有碰撞检测，但是没有物理效果(比如剑和魔法穿过人物)。
Rigidbody直接加在父对象上，会把子对象都包括进来，Collider也是，父对象的碰撞检测会使用所有子对象累积起来的形状参与检测
网格碰撞器开启刚体必须开启Convex才能参与刚体计算。
在代码中检测
碰撞和Trigger属于特殊的生命周期函数，在FixedUpdate之后固定调用,调用循环间隔和Update不一样，也是通过反射调用。
只要挂载的对象能和别的对象产生碰撞和触发，那么对应的函数就会响应，有物理效果的是Collison没有的是Trigger，自己没挂别的挂了碰我也会触发
默认private，可以写成protected去子类中去重写，一般不会手动调用所以不要写成public。
参与计算的是Rigibody组件，父物体挂组件子物体挂了脚本触发不了的。
Rigibody添加力的单位是牛N，如果没阻力就会一直飞，想要一直动就一直加力和物理世界一样。注意爆炸力函数只对挂载的本脚本的物体起效，所以模拟爆炸就获得所有受影响的物体然后执行这个函数
使用组件ConstantForce组件，可以直接在面板上为物体施加力场，注意Unity有刚体休眠机制节约性能，如果发现刚体不好使了，叫醒一下
Csharp
public class Rigid : MonoBehaviour
{
private Rigidbody rigidBody;
void Start()
{
rigidBody = gameObject.GetComponent<Rigidbody>(); // 获得刚体组件
rigidBody.AddForce(Vector3.forward*10); // 添加相对于世界坐标系方向的力
rigidBody.AddRelativeForce(Vector3.forward*10); // 添加相对于自己标系方向的力
rigidBody.AddTorque(Vector3.forward*10);// 添加扭矩力
rigidBody.AddRelativeTorque(Vector3.forward*10);// 添加相对于自己标系方向的扭矩力
rigidBody.AddExplosionForce(100,Vector3.zero, 10); // 爆炸力 爆炸中心 爆炸半径
rigidBody.AddForce(Vector3.forward*10,ForceMode.Force); // 第二个参数是施加力的模式，力的函数都可以添加
rigidBody.velocity = Vector3.forward*10; // 很少用，可以直接改变速度
}
private void OnCollisionEnter(Collision collision) // 刚碰撞到
{
print(collision.collider); // 获得对方碰撞器的信息
print(collision.gameObject); // 获得对方游戏对象
print(collision.transform); // 获得对方的位置信息
print(collision.contactCount); // 获得有哪些点碰撞了
ContactPoint[] pos = collision.contacts; // 甚至获得所有碰撞了的点（不常用
}
private void OnCollisionExit(Collision collision){} // 结束碰撞的
private void OnCollisionStay(Collision collision){} // 持续碰撞过程中
/* Collider 对象属性和Collison差不太多,点进去看着属性拿 */
private void OnTriggerEnter(Collider other) {} // 刚开始接触
private void OnTriggerExit(Collider other){} // 结束接触，穿越过去的时候
private void OnTriggerStay(Collider other){} // 两者正在穿模的时候
void Update()
{
if(rigidBody.IsSleeping()) rigidBody.WakeUp(); // 当然也有rigidBody.Sleep()
}
// 让物体位移的方式，position赋值，Translate，AddForce,
}#todo 力的模式和计算,父子物体的碰撞器组合实现CompositeCollider2D的效果 使用meshcollider太费性能了，所以可以加多个碰撞器拼个大概就行了，节省性能。
被检测的对象必须要有碰撞器。范围检测不会真正产生新碰撞器，而且检测是瞬时的。生成的触发器形状和默认能创建的那几个物体类型一样，最后会获得一个检测到的Coillder数组
Csharp
Collider[] colliders = Physics.OverlapBox(Vector3.zero, Vector3.one, Quaternion.AngleAxis(45,Vector3.up), // 中心 大小 旋转角
1<<LayerMask.NameToLayer("UI"), // 检测哪一层
QueryTriggerInteraction.Ignore); // 是否忽略触发器
Collider[] colliders = Physics.OverlapSphere(transform.position+transform.forward+transform.up, 1, // 中心(自己的位置往上和前偏移1个单位)，半径1
1<<LayerMask.NameToLayer("Monster")); //这里创建的是球形范围检测
// Physics.OverlapBoxNonAlloc多了个参数，直接先传入碰撞器数组存储结果，和ref一样 调用者负责初始化数组，方法只负责填充数据。QueryTriggerInteraction是个枚举类，默认值是使用Unity中的设置Edit->ProjectSettings->Physics->QueriesHitTriggers默认是勾上的，是否检测触发器Trigger。
射线检测 也是瞬时的。
注意Physics.RaycastAll 距离从远到近排序 排序的，最远的在index0
Csharp
void Start()
{
Ray r = new Ray(transform.position, transform.forward); // 从哪个点发出射线，以及射线的方向向量
print(r.origin);
print(r.direction);
Ray r2 = Camera.main.ScreenPointToRay(Input.mousePosition); // 从摄像机位置发条射线到鼠标的位置
}
void Update()
{
Ray r3 = new Ray(Vector3.zero, Vector3.forward); // 搞一条射线
bool isHit=Physics.Raycast(r3,1000,1<<LayerMask.NameToLayer("Monster")); // 只返回是不是碰到了 也可以传QueryTriggerInteraction
if (Physics.Raycast(Vector3.zero, Vector3.forward, 1 << LayerMask.NameToLayer("Monster")))
{
print($"Hited {isHit}");
}
if (Input.GetMouseButtonDown(0))
{
Debug.Log("常见 鼠标点击检测碰撞点并导航");
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
agent.SetDestination(hit.point);
agent.isStopped = false;
Debug.Log("目标点: " + hit.point);
}
}
RaycastHit rh;
if (Physics.Raycast(r3,out rh,1000,1 << LayerMask.NameToLayer("Monster")))
{
print(rh.collider.gameObject.name); // 这样就拿到了碰到了谁，只能拿到第一个碰到的
print(hit.point); // 获得碰撞点
print(rh.distance);// 获得离我多远
print(rh.normal); // 获得碰撞的法线向量
}
RaycastHit[] rhs = Physics.RaycastAll(r3, 1000, 1 << LayerMask.NameToLayer("Monster"));
if (rhs.Length!=0)
{
foreach (RaycastHit r in rhs)
{
print(r.collider.gameObject.name);
}
}
}顺口把这俩API也看一眼，这俩是调试用的射线
Csharp
Debug.DrawLine(A.position, B.position, Color.red, 0.1f);// 绘制从 A 到 B 的红色线段 显示时间0.1s
Debug.DrawRay(A.position, A.up * 5, Color.green, 0.1f); // 绘制从 A 出发的绿色射线，向 A 的上方方向 显示时间0.1s物理材质和显示的模型材质不同，物理材质规定的是碰撞时物理特性。右键创建之后可以在Collider中为对象分配。
使用LineRenderer组件 可用多个点划一些线段，点的多少可以增加减少，他会把点连起来绘制线段，每个对象身上只能有一个LineRenderer
Csharp
lineRenderer.positionCount = 4; // 必须要先规定个数
lineRenderer.SetPositions(new Vector3[] {
new Vector3(0, 0, 0),
new Vector3(0, 0, 5),
new Vector3(5, 0, 0)
});
lineRenderer.SetPosition(0, new Vector3(0, 0, 0)); // 重载可以指定操作常用兼容格式mp3 wav ogg aiff面板下面能预览，参数中比较重要的是 LoadInBackground后台加载不阻塞主线程 LoadType性能和内存取舍参数 Preload Audio Data场景使用前是否预加载音效
[ 💬Quote ] 参数一览
AudioSource组件是让 GameObject发出声音的组件。AudioListener是声音监听器，可以理解为声音总线，一般会跟随摄像机挂载有且仅有一个多了删掉，如果出现了多个AudioListener会报警告。 注意参数：
[ 💬Quote ] 参数一览
使用代码控制音频
没开始Play是不能Pause的。动态控制音频常用的方式，可以直接搞好挂对象身上；可以挂在一个prefab上然后动态生成销毁；可以通过指定clip用一个AudioSource组件管理。PlayOneShot 允许你在一个已有的 AudioSource 组件上播放一次AudioClip，而不会影响当前正在播放的音频，例如播放背景音乐的同时播放角色行走或射击的音效
AudioClip类要用浮点数组存储，长度是 声道数x剪辑长度 可以Get和Set数据
麦克风输入音频 frequency默认就填44100，返回的是一个AudioClip
[ ⚠️Warning ]
一个AudioSource管一个音效，如果使用同一个， 那PlayOneShot和Play可能会会被一块触发导致重叠播放，比如上面想用按键控制攻击音效的时候，背景音乐同时也会跟着起停。所以改为了获取两个组件（问题来了我怎么知道我获取的组件顺序哪个是BGM哪个是攻击）
Unity 在内部使用的是 底层音频系统（如 FMOD、OpenAL、平台音频 API） 来初始化音频设备不会动态检测设备热切换，官方确认这是预期行为暂时没有解决方案
Csharp
public class AusT : MonoBehaviour
{
private AudioSource aus;
public AudioClip clip;
public AudioClip RecordClip;
// Start is called before the first frame update
void Start()
{
aus=GetComponent<AudioSource>();
string[] microps=Microphone.devices; // 所有的麦克风设备
foreach (string microp in microps)
{
print(microp);
}
print(clip.length) // 获取音频长度
}
// Update is called once per frame
void Update()
{
if(Input.GetKeyDown(KeyCode.P)) aus.Play(); // 这个Play的delay参数是根据采样率来的，最好别直接用
if(Input.GetKeyDown(KeyCode.S)) aus.Stop();
if(Input.GetKeyDown(KeyCode.Space))
{
// 实际上Unity没有提供音效是否播放完毕的API，用isPlaying一直检测，直到播完
if(aus.isPlaying) aus.Pause(); // 暂停再开始会接着播
else aus.UnPause(); // 暂停之后用也行
}
if(Input.GetKeyDown(KeyCode.C))
aus.clip=clip; // 更换clip
if (Input.GetKeyDown(KeyCode.R))
{
// 设备使用默认选null loop如果录制超长会重录 录制长度(S) 采样率一般就这个固定数44100
RecordClip= Microphone.Start(null, false, 10, 44100);
}
if (Input.GetKeyUp(KeyCode.R))
{
print(Microphone.IsRecording(null)); // 录制完了吗
Microphone.End(null); // 结束
aus.PlayOneShot(RecordClip); // 不知道为什么我这里能录制，能调用麦克风 但播放会有问题
float[] f = new float[RecordClip.channels*RecordClip.samples]; // 浮点数组存储，存储的长度是 声道数*剪辑长度
RecordClip.GetData(f, 0); // 直接Get出来塞进去
}
}
}视频播放内置的VideoPlayer已经很好用了没必要玩的三方。MovieTexture很老了别用。
一般都用mp4+H.264就够,平台发布比较广可以使用VP8比h264性能差点兼容性好。
支持h.265编解码器的平台macOS 11.13+，Windows 10，Android 5.0+，iOS 11.0+。
| 平台兼容性 | Windows | macOS | Linux |
|---|---|---|---|
| .asf | ✓ | ||
| .avi | ✓ | ||
| .dv | ✓ | ✓ | |
| .m4v | ✓ | ✓ | |
| .mov | ✓ | ✓ | |
| .mp4 | ✓ | ✓ | |
| .mpg | ✓ | ✓ | |
| .mpeg | ✓ | ✓ | |
| .ogv | ✓ | ✓ | ✓ |
| .vp8 | ✓ | ✓ | ✓ |
| .webm | ✓ | ✓ | ✓ |
| .wmv | ✓ |
更多平台兼容性参考
目标平台兼容性:
#if视频的Inspector参数一览
原生VP8编解码器在Android平台上并不支持透明度所以必须启用转码。目的是为了让Unity等应用程序能够使用其内部机制来处理和表示Alpha通道.AudioSampleProvider buffer overflow. XXXX sample frames discarded.某些平台导入视频之后会出现丢失音频帧没声音，不知道为啥重启就好了。
视频播放使用VideoPlayer组件，关联你的VideoClip。
先看Inspector：
看代码面板上有的一眼能对上的不写。
Csharp
public class videoplay : MonoBehaviour
{
public RenderTexture texture;
public VideoClip clip;
VideoPlayer videoPlayer;
void Start()
{
videoPlayer = Camera.main.gameObject.AddComponent<VideoPlayer>();
videoPlayer.playOnAwake = false;
videoPlayer.renderMode = VideoRenderMode.CameraFarPlane;
//videoPlayer.targetTexture = texture; // 贴图模式才能用
//videoPlayer.targetCamera
videoPlayer.targetCameraAlpha = 0.5f;
//videoPlayer.targetCamera3DLayout = Video3DLayout.OverUnder3D;
videoPlayer.source = VideoSource.VideoClip;
videoPlayer.clip = clip;
//videoPlayer.source = VideoSource.Url;
//videoPlayer.url = Application.streamingAssetsPath + "/Video.mp4";
print(videoPlayer.length);//总长多少秒
print(videoPlayer.time);//播放了多少秒 可以设置它以从某个时间播放
print(videoPlayer.frameCount);// 总帧数
print(videoPlayer.frame);// 当前播放了多少帧
videoPlayer.Prepare(); // 需要先准备完才能播，可以提前准备，搭配WaitForFirstFrame用。
videoPlayer.prepareCompleted += (v) => print("准备完成事件");// 这里就可以传标志位准备好了按键再播
videoPlayer.started += (v) => print("开始Play的事件");
videoPlayer.loopPointReached += (v) =>print("结束Play的事件");
}
void Update()
{
if(Input.GetKeyDown(KeyCode.Space))videoPlayer.Play(); //视频播放
if (Input.GetKeyDown(KeyCode.S))videoPlayer.Stop(); //视频停止
if (Input.GetKeyDown(KeyCode.P)) videoPlayer.Pause(); //视频暂停
}
}全景视频先不搞
常识类的跳过，窗口在Window->Animation->Animation，创建对象可以Assets->Create->Animation。动画除了K帧按钮之外还可以添加事件，播放到这个地方的时候就会触发指定的事件。 面板上定位的不是秒数而是当前帧数，默认是60fps
关键对象:
新动画系统，Mecanim动画系统主要用Animator状态机组件来控制动画。
人物的动作是有限的，且同一时间只能有一个动作状态，而且随时可以切换(任意状态)，动画和游戏AI是有限状态机应用的绝佳场景。
AnimatorController可以在Animator窗口中编辑，注意窗口中的重要参数:
多种怪物和角色复用状态机，Project->右键Create->AnimatorOverrideController，关联需要继承和改变的状态机，然后就可以替换所有的AnimationCliper，达到保留原状态机调整的参数和事件，只替换掉动作复用的效果。
和AnyState连接的Transition要取消勾选CanTransitionToSelf，不然死了会一直自己切换自己，循环播放最后一个一直抖
Csharp
public class AnimeTest: MonoBehaviour
{
Animator animator;
void Start()
{
animator = GetComponent<Animator>();
animator.runtimeAnimatorController = Resources.Load<RuntimeAnimatorController>(monsterInfo.animator); // 可以在运行时通过Resources动态加载Animator资源赋值
}
void Update()
{
bool b1 = animator.GetBool("b1");
bool b2 = animator.GetBool("b2");
animator.SetBool("b1",true);
// 可用API包括 SetFloat SetInteger SetTrigger；Get同理
}
}[ ⚠️Warning ] 新老动画系统中的AnimationClip不能通用
拖进去之后AnimatorController中的State绑定不了旧Clip，可以手动转换或者创建新的。
老动画系统，Animation动画系统用Animation组件代码来控制动画
在需要动画的物体上挂载Animation组件，此时不会在自动创建Animator和AnimatorController，这个组件上的参数:
Csharp
public class TestAnimation : MonoBehaviour
{
private Animation anim;
void Start()
{
anim = GetComponent<Animation>(); // 获得动画组件
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Alpha1))
{
anim.Play("anime1"); // 播放动画1
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
anim.Play("anime2"); // 会把当前动画中断去播放动画2
anim.CrossFade("anime2"); // 把当前动画中断但是系统会自动计算一个插值，去播放动画2，看起来更顺畅
anim.PlayQueued("anime2"); // 队列播放，放完上一个才放动画2，但是也没有过渡
anim.CrossFadeQueued("anime2");
}
if (Input.GetKeyDown(KeyCode.S))
{
anim.Stop();// 停止所有动画
}
if (anim.isPlaying == true)
{
Debug.Log("有动画正在播放");
}
if (anim.IsPlaying("anime2"))
{
Debug.Log("正在播放动画2");
}
}
public void AnimationEvent(int param1) // 界面上可以为动画事件传参数，什么都可传
{
Debug.Log($"Trigger AnimationEvent total Frame: {Time.frameCount}");
}
}导入规范上面写了不重复，一个fbx Assets 的设置主要这四个Model Rig Animation Materials
先记一下需要加深印象的参数，其他参数用到了去查或者问AI
Model：
.fbx .max .jas = 0.01 .3ds = 0.1 .mb .ma .lxo .dxf .blend .dae = 1状态机行为脚本 在State上可以挂脚本，这个脚本比较特殊，继承StateMachineBehaviour，当角色进入、退出或保持在某一个特定状态时，可以通过这些脚本进行一些逻辑处理。就是在AnimatorController状态机窗口中的某个状态添加一个脚本来实现一些特殊功能，比如播放声音检测落地播放特效等
主要的生命周期函数，必须overraid指定的函数进行操作，参数都是一样的。+
Animator animator 挂载的动画组件
AnimatorStateInfo stateInfo 脚本挂载的状态
int layerIndex 状态所在的层
OnStateEnter 进入状态时，第一个Update中调用
OnStateExit 退出状态时，最后一个Update中调用
OnStateIK 在OnAnimatorIK后调用
OnStateMove 在OnAnimatorMove后调用
OnStateUpdate 除第一帧和最后一帧，每个Update上调用
OnStateMachineEnter 子状态机进入时调用，第一个Update中调用
OnStateMachineExit 子状态机退出时调用，最后一个Update中调用状态机行为脚本 和 Events动画事件相比更精确，但是更麻烦
动画分层 比如上半身播放开枪动画，下半身可以蹲跑跳，由不同的动画层组合播放。在Animator窗口中，添加状态机Layer，每个Layer对动画的影响是同时施加的。 Layer的参数：
混合树
在AnimatorController->CreateState->FromNewBlendTree创建一个混合树，双击混合树可以编辑。
在Blend参数那可以选择类型，1D混合树就是只用一个参数控制的混合树，此时就已经自动创建了一个参数。
此时就有一个可以调节的二维坐标，X轴即为变量，Y轴即是播放Motion里哪个的Threshold权重，会按照权重混合起来播放。可以在Motion中调整权重和速度 。
AutomateThreshold自动权重会自动平分权重（一般就是0-1之间的权重，使用混合树可以达到参数逐渐增加动作从idle->walk->run这个效果，当然衔接和相似度越高看起来越好。
2D混合就是两个参数控制动画混合程度。在Paramters中指定绑定的参数。
混合树嵌套看混合树的工作流图，就可以知道怎么嵌套的
此时在图表中就可以编辑不同的Motion的权重位置，三种2D混合树只是算法不同，作用是一样的。
子状态机
可以把多个状态机连成一个子状态机，直接在AnimatorController->Create->SubStateMachine.
注意: 连接UpperStateMachine的时候，如果直接连出去会播放上层的默认动画，连过去的时候右键UpperStateMachine可以选择转移到上层哪个状态
IK控制 在动画Animator窗口->Layer的设置IK Pass此层的动画才会受到IK影响，IK动画控制用来捡东西弓箭锁定瞄准，上半身随着鼠标旋转下半身走路等场景。
IK在Update和LateUpdate之间被调用，也就是说会在每帧的状态机和动画处理完后调用OnAnimatorIK(处理IK)在OnAnimatorMove(处理根运动)之前调用
Csharp
public class CodeIK : MonoBehaviour
{
public Animator ant;
public Transform pos;
void Start()
{
ant = this.GetComponent<Animator>();
}
private void OnAnimatorIK(int layerIndex) // 特殊生命周期函数
{
ant.SetLookAtWeight(1,1f,1f);// 设置头部IK权重，这函数重载了5次，注意参数，去界面上调一调。
// weight: 全局权重
// bodyWeight: 身体的权重
// headWeight: 头部的权重
// eyesWeight: 眼睛的权重
// clampWeight 限制角色转动幅度的权重0不限制1完全不能转动0.5转一半
ant.SetLookAtPosition(pos.position);// 设置头部IK看向的位置，可以目光和头跟着位置动
ant.SetIKPositionWeight(AvatarIKGoal.RightHand, 1); // 设置Avatar某个IK点(四个枚举可以在Avatar骨骼那里查看)的位置权重
ant.SetIKRotationWeight(AvatarIKGoal.RightHand, 1); // 旋转权重
ant.SetIKPosition(AvatarIKGoal.LeftHand,pos.position);
ant.SetIKRotation(AvatarIKGoal.LeftHand,pos.rotation);
}
}动画目标匹配，比如跳过障碍，脚指定落点抓住房梁等。
[ ⚠️Warning ] 调用目标匹配限制
必须保证动画已经切换到是目标动画上，不能在(前后)过渡阶段，开启ApplyRootMotion根运动
注意调用方式，可以通过动画的Events触发，保证满足目标匹配的触发限制
Csharp
public class MatchMotion : MonoBehaviour
{
private Animator ant;
public Transform jumpTarget;
void Start()
{
ant = GetComponent<Animator>();
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
ant.SetTrigger("Jump"); // 只触发动画
}
}
public void Jump() // 通过动画的Events触发，保证满足目标匹配的触发限制
{
Debug.Log("jump trigger");
ant.MatchTarget(jumpTarget.position,// 目标位置，角度
jumpTarget.rotation,AvatarTarget.LeftFoot,// 匹配的骨骼位置播放完之后哪个位置要和指定的位置重合
new MatchTargetWeightMask(Vector3.one, 1),// 位置角度权重。位置权重X/Y/Z 轴的权重都是1，表示完全匹配位置（移动到目标位置）旋转匹配权重：1，表示完全匹配旋转（朝向与目标一致）。
0.4f,// 开始位移动作的百分比，播放到百分之多少开始位移
0.63f);// 结束位移动作的百分比
}
}人形Avatar更合适角色控制器，添加角色控制器之后不需要再添加刚体，能检测触发器 碰撞 射线，使用的时候需关闭Anmiator的ApplyRootMotion使用角色控制器的好处是可以避免使用刚体判断碰撞时容易撞飞斜坡滑动抖动等角色bug，控制角色更稳定。 CharacterController组件，用了这个就不用Collider和Rigidbody, 自带一个Collider不过形状未知。
controller.Move(Vector3)注意组件的方法characterController.isGrounded返回布尔值，检测是否在地面上。characterController.Move(vector3.forward); 和transform.Translate类似,没有重力适合平地，需要传递向量，数值大小会直接影响移动速度，所以要乘Time.deltaTimecharacterController.SimpleMove(vector3.forward);在Update里调用会自动应用重力，需要传递一个速度，不受帧率影响，不需要乘Time.deltaTimepublic void OnControllerColliderHit(ControllerColliderHit hit){} 额外提供了碰撞检测函数，接收被碰撞的对象，但是常规的碰撞函数就没用了，常规的触发器函数还有用
Unity的寻路本质是A星寻路的拓展和优化，A星只支持2D和静态阻挡，navi3D和动态阻挡都支持。
2代和一代不太一样，新版本的支持动态烘焙
注意这几个重要的对象 导航网格 (NavMesh) 导航网格寻路组件 (NavMesh Agent) 导航网格连接组件 (Off-Mesh Link) 导航网格动态障碍物组件 (NavMesh Obstacle)。 导航的单位都是米
做导航的流程，定义地形和消耗，烘焙，设置导航寻路Agen，设置障碍。
[ ⚠️Warning ]
注意如果已经烘焙好了导航网格会无视碰撞体直接穿过去，所以最好障碍一块烘焙导航网格，烘焙网格不能运行过程中动态生成。
2022之后的版本需要额外安装Window->PackageManager->AI Navigation才能启用老版本。装完在Winodow->AI->Navigation(Obsolete)打开。
地形烘焙:
Object 中可以过滤场景中物体，方便设置导航属性，在Static中设置导航静态NavigationStatic物体才能参与地形烘焙。Terrins是挂载了的地形脚本的对象
Area 中可以规定导航区域的寻路消耗，在Object的 NavigationArea中选择，寻路的时候会根据消耗和路径选择消耗最少的路径。 Bake 参数一览:
NavMeshAgent组件：需要导航的对象挂上就多了一个寻路检测盒，参数:
Csharp
void Update()
{
if (Input.GetMouseButtonDown(0))
{
Debug.Log("鼠标点击导航点");
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
agent.SetDestination(hit.point); // 设置导航目标点
agent.isStopped = false; // 停止导航，再次导航必须打开
Debug.Log("目标点: " + hit.point);
}
}
if(agent.velocity.sqrMagnitude < 0.01f) animator.SetBool("run",false); // 利用速度判断动画状态机
else animator.SetBool("run",true);
}
#region 不常用API
print(agent.speed); //1.面板参数相关 速度
print(agent.acceleration); //1.面板参数相关 加速度
print(agent.angularSpeed); //1.面板参数相关 旋转速度
if(agent.hasPath){} //2-1当前是否有路径
print(agent.destination); //2-2代理目标点 可以设置 也可以得到
print(agent.isStopped); //2-3是否停止 可以得到也可以设置
print(agent.path); //2-4当前路径
if(agent.pathPending){} //2-5路径是否在计算中
print(agent.pathStatus); //2-6路径状态
agent.updatePosition = true; //2-7是否更新位置
agent.updateRotation = true; //2-8是否更新角度
print(agent.velocity); //2-9代理速度
NavMeshPath path = new NavMeshPath();
if(agent.CalculatePath(Vector3.zero, path)){} //计算生成路径
if(agent.SetPath(path)){} //设置新路径
agent.ResetPath(); //清除路径
agent.Warp(Vector3.zero); //调整到指定点位置
#endregionagent.velocity 的开销极低 velocity 是 NavMeshAgent 的一个属性，本质是 Unity 内部已经计算好的一个 Vector3，取它只是一次内存读取。sqrMagnitude 只是 xx + yy + zz 三次乘法一次加法，比 Magnitude（会开平方）更省。 animator.SetBool 也是轻量操作 Animator 参数更新是在下一帧的动画系统中批量处理的，你调用 SetBool 只是把值写到一个缓存，并不会立刻重算整套动画。
OffMeshLink网格外连接组件 他可以挂在任何一个东西上，只要把start end 拖上去就行
参数:
区域消耗值*CostOverrideNavMeshObstacle动态障碍组件，给物体挂上就会有一个导航体积盒，可以运行中动态计算导航
Carve 该障碍会在烘焙网格上动态开孔，固定不动的建议为true(门栅栏什么的)，移动的不用(玩家汽车什么的)
#todo 这个障碍被玩家点击破坏才能通过练习题核心P95
现在内置的已经是新版本了。 新版本把Bake和Object独立出来了，在任意组件上挂载NavMeshSurface组装一下，
你说熟悉Unity的导航寻路，那我问你--1.如何用网格表示世界_哔哩哔哩_bilibili
【Unity3D基础】【导航系统】新版本导航系统的使用方法_哔哩哔哩_bilibili
全网最详细Unity NavMesh寻路第一期：基础讲解，烘焙场景_哔哩哔哩_bilibili
类似下雪下雨法球之类的，很多都用到粒子，程序主要是使用粒子，而不需要自己做粒子。
粒子就是普通的空gameObject，但是挂载了Particle System(Create->Effects->ParticleSystem) 在ParticleSystem组件下，以下几个属性常用：
在开始选择的时候2D和3D只是预设不同，其他的没什么区别，但是我也不知道为什么有些东西建了3D项目导入不进去2D就可以比如标准包里的瓦片
| 大致看一眼留个印象 | 2D 工程（默认设置） | 3D 工程（默认设置） |
|---|---|---|
| 摄像机投影方式 | 正交 (Orthographic) | 透视 (Perspective) |
| 场景视图模式 | 默认启用 2D 视图 | 默认启用 3D 视图 |
| 对象坐标轴方向 | X（横）、Y（竖） | X（横）、Y（高）、Z（深度） |
| 图片导入类型 | Sprite | Texture（Default） |
| 精灵渲染组件 | SpriteRenderer | MeshRenderer |
| 碰撞体类型 | Collider2D 系列（Box2D） | Collider 系列（PhysX） |
| 刚体组件 | Rigidbody2D | Rigidbody |
| 地面检测/射线等默认行为 | 使用 Physics2D | 使用 Physics |
| 默认物理引擎 | Box2D（2D 物理） | NVIDIA PhysX（3D 物理） |
| Tilemap 支持 | 默认包含（可用于地图编辑） | 需手动添加 Tilemap 支持 |
| 渲染管线 | 通常为 Built-in 或 2D Renderer（URP） | 通常为 Built-in、URP 或 HDRP |
| 照明系统 | 基本无光照（除非手动添加） | 支持光源、阴影、材质、反射等 |
需要搞懂的几个流程概念：
概念不赘述，想不起来的搜。
伽玛颜色空间，详细的解释，Unity的颜色空间文档
建模一般使用三角形面片，因为在数学和物理上有天然优势。三角形是唯一总是共面的最小多边形，无论三个顶点怎么放，都始终在同一个平面上 的图形；图形硬件和渲染管线只支持三角形；三角形可以组成任意复杂模型，不存在“无法拼出来”的情况。建模和美术工具链中三角形是公认标准
[ 📌Tip ] Unity支持的图片格式
导入了图片之后在Inspactor面板可以选择材质类型(TextureType) 贴图，法线贴图等等。怎么这么多参数要记 TextureType类型,大致记一下就好，遇到增量补充:
[ 📝Note ] Mipmap技术
在3D场景中，如果镜头离材质贴图很远，那么材质的像素就会被压缩采样，比如四个像素采样一个。这样会采样不足渲染失真，远景出现锯齿摩尔纹和运动噪点。
Mipmap技术就是预先从原分辨率材质生成不同层级大小的材质最小为1*1然后根据摄像机远近应用不同层级采样解决这个问题。
Mipmap的纹理比原始纹理小很多，更容易被GPU的纹理缓存容纳，可以提高缓存命中率，但是总显存占用率大约+33%
2D和UI一般不启用，3D项目显存不是特别紧张最好是开，没用到的地方就别打开。Mipmap的选择模式Bilinear选择最相邻的一个层级 和 Trilinear选择最相邻的两个层级进行插值采样
TextureShape 纹理形状，Cube用于天空盒和反射探针，Mapping是如何将纹理投影到游戏对象上，进阶的时候在天空盒会讲 纹理平台设置 很重要，和性能相关
在Window->PackageManager->2D Sprite安上才能用，还不能用看看自己预设是不是选成了3D项目
SpriteRenderer是可以挂载Sprite的组件。
Csharp
public class SpriteTest : MonoBehaviour
{
// 挂在Sprite对象上的组件
private SpriteRenderer spriteRenderer; // 声明一个spriteRenderer
public Sprite sprite; // 声明一个Sprite对象
void Start()
{
spriteRenderer = gameObject.GetComponent<SpriteRenderer>(); // 获得本Sprite的Renderer
spriteRenderer.sprite = sprite; // 可以替换掉
spriteRenderer.color = Color.cyan; // 其他属性参考着吗面板改
//动态加载图集
Sprite[] = sprs = Resources.LoadAll<Sprite>("RobotBoyIdleSprite");//这里是图集的名字，从数组里取对应的Sprite
}
}可以直接Create->Sprite->形状，还没出美术素材作为替代资源，等出了之后换上就行了。
Create->SpriteMask可以创建遮罩，注意遮罩对象的CustomRange属性，只有在这个层级内遮罩才能起效，新加Layer是下方Layer的0-N，新Layer的0-Front
使用SortingGroup组件可以整体的加一个排序分组，比SpriteRender的AdditionalSettings->SortingLayer优先级还要高。子对象的SortingGroup只会在同级别发作用，对上层的无效，而且是优先于Z轴发挥作用的。
如果这个组件被放进了Prefabs中，拖出来的时候为了避免有同样值的SortingGroups冲突最好修改一下。
打图集将多个纹理texture合并成一个大纹理，当访问图集中的多个纹理时，也只需要调用一次DrawCall， 默认是不会打图集的。在Edit->ProjectSettings->Editor->SpritePacker中打开
选择Sprite Atlas V2 - AlwaysEnabled,右键在资源文件夹中Create->2D->Sprite Atlas，一般会通过代码动态加载它
Sprite Atlas V1 不支持缓存服务器（Cache Server），Unity只能将打包的图集数据存储在
Library/AtlasCache文件夹中，并且也不能有依赖项，不支持命名对象导入器（named objects importer），而Sprite Atlas V2提供了对上述功能的支持。具体可以参考 Unity Manual：Sprite Atlas Version 2
主图集（Master）
把Texture或者包含Texture的文件夹拖进来就可以放进图集就行。如果发现没有PackPreview按钮，说明忘了打开允许图集。
直接使用Texture的时候，他会自动使用图集的，在 Game窗口->Stats(Statistics)->Batches就是DrawCall的数量看看有没有变，注意只有运行的时候才会变化
注意 如果一个图集的两个Texture中间有其他SortingLayer的Texture，此时图集会触发两次Drawcall，拼UI尤其注意 ！
Csharp
SpriteAtlas spriteAtlas = Resources.Load<SpriteAtlas>("MyAtlas"); // 和加载普通资源一样
sr.sprite = spriteAtlas.GetSprite("sprite1");图集的尺寸最佳实践
如果 Sprite Atlas 设置的最大尺寸为 2048x2048，而所有 Sprite 加在一起超过了这个尺寸，Unity 会自动拆分成多个图集纹理（Texture），所以此时Drawcall也是两次。Sprite Atlas → Inspector → 下方可以看到 “Objects Preview”有没有被拆分 注意不同平台（Android/iOS）支持的最大纹理尺寸略有不同。旧设备普遍不支持大于 2048。
同样需要在Window->PackageManager中安装才能使用,主要用来拼接2D游戏中不规则的地形的
SpriteShapeProfile
安装完此时右键在Assets右键Create->Sprite（创建SpriteShapeProfile）每个版本貌似路径还不太一样只要创建出这个文件就可以。
新版本的close和open的版本合并了，close的是封闭的一个圈可以使用很多;open就可以随便加折线编辑使用的是一个Texture。可以在圆圈上设置角度，然后点过去就可以设置这个角度区间的材质了
SpriteShapeController参数几乎一看就会
SpriteShapeRenderer
为这东西添加碰撞器有两种
边界碰撞器EdgeCollider2D会直接顺着中轴线添加碰撞器
多边形碰撞器PolygonCollider2D+复合碰撞器CompositeCollider2D，然后PolygonCollider2D->UseByComposite形成类似边界碰撞器的效果，多边形碰撞器必须使用Rigidbody，如果想让它不动就得选择成Static有检测碰撞限制
需要在Window->PackageManager中安装2DTileMapEditor才能使用，也是用来创建2D地图。关键的是两个文件，一个是Tile.asstes文件和TilePalette预制体，点击预制体能打开TilePalette编辑器。
安装完后在 Asset->Create->2D->TilePalette 选择一个类型 或 Window->2D->TilePalette打开窗口，这样我们就创建了一个新的瓦片调色盘TilePalette，把这东西拖进场景中，再把Sprite拖进调色盘就创建了瓦片
[ 📝Note ] 和SpriteShape差异
SpriteShape可以让地形具有弧度，适合制作曲线圆形等不规则形状的地图元素。
TileMap更适合由方块组成的平铺地图，可以通过层叠不同图层来快捷地制作有伪“Z”轴效果的地图，即模拟出三维空间的效果。
这一节更接近美术，在untiy中看着弄比较好。
创建TilePalette的时候，注意几个参数
滚轮中键 或 alt+左键 平移视角，放大缩小单选多选就不多说了，瓦片编辑器和PS一样，美术相关的不多说（就是魔兽地图编辑器一样的，都可以编辑。
调色盘的正确用法是，把TilePalette当调色盘用，把所有可能用到的瓦片拖进来一份，在Scene中Create->2D->Tilemap->选一个 就创建了一个Grid，然后用笔刷工具吸取自己想要的色块绘制Grid。
等距ZasY瓦片地图的排列是按照Sprite的轴心点定位的，有些素材不是中心贴合的。在等距瓦片Grid中默认是按照Z轴排序的，在ProjectSetting->Graphics->TransparencySortMode: Custom->TransparencySortAxis: (X,Y,Z)=(0,1,-0.26)，设置Grid对象的TileMap中设置TileMap的Mode为Individual，然后高低差就正常了。在TilePalette的Brush中勾掉LockZPosition就可以使用 - + 键调整地形的高度，他使用Y轴模拟了高度。
Grid组件是网格的基本组件，参数一看就懂，注意网格大小<->Sprite PixelPerUnite对应，调整格子和Sprite的填充。
TileMapRenderer组件，SortOrder设置所选瓦片地图上的瓦片排序方向，带Z轴模拟的一般左上角，其他一般默认右下角就行；Mode渲染模式，chunk按位置分组批处理渲染瓦片，Individual单独渲染每个瓦片，带位置和排序顺序
选择需要添加Collider的TileMap层，然后添加TileMapCollider2D然后自动根据有Sprite的格子生成了Collider，注意格子生成瓦片使用的Collider格式。
轴心点排序: 参与等距网格的角色一般把Sprite的中心点设置为脚下(0.5X,Y)，地图上的Sprite的SpriteSortPoint需要设为Pivot，轴心点排序，Sprite的轴心点如果在指定地图轴心点Y轴的上方那就会显示在前面。这样就会影响轴心点画地图不太推荐
排序层排序: 可以创建多个等距瓦片地形，给不同的OrderInLayer，形成植被景观等效果分层，但是不同层不会产生遮挡，1.这时候可以再创建一个层，比玩家层高绘制的东西就可以挡在玩家前面；2.如果是植物这种，把它和玩家放一个层都设置好轴心点排序，控制轴心点
一般在这种2D游戏中，不会使用重力和Rigidbody控制移动，而是使用Transform。伪Z轴碰撞的话，地形瓦片Sprite是不使用碰撞的， 墙体瓦片Sprite使用Gride碰撞，会约束玩家在格子里。如果碰撞在本层网格上看起来靠不到边，那就再在外面叠一层让它和外面的进行碰撞。
2.5D的跳跃动画可以创建一个空父物体，跳跃的时候让人物子物体在Y轴动。
旧版本去github下载对应版本，然后拖进Assets导入；2020之后的版本直接在Window->PackageManager中安装
感觉这东西一时半会用不到，而且好多年没更新了，进行一个挖坑然后有空了再补TIleMap Extra
Csharp
public Tilemap map; // 瓦片地图
public Grid grid; // 布局，可以有多层瓦片
public TileBase tile; // 瓦片
public TileBase new_tile;
void Start()
{
map.ClearAllTiles();// 直接清图
TileBase tile = map.GetTile(new Vector3Int(0,0,0)); // 获得这个map坐标上的Tile
map.SetTile(new Vector3Int(0,0,0), tile); // 把指定位置替换成这个瓦片，SetTiles可以设置多个，清理格子可以用null
map.SwapTile(tile,new_tile); // 把地上所有的 tile类型 替换成 new_tile类型
grid.WorldToCell(Vector3.zero); // 把指定的世界坐标转换为指定的格子的坐标
}先看一下参数，重点记和3D不同的参数。
前提条件和3D的碰撞体刚体一样，必须两者都有Collider至少一个有Rigidbody，2D的碰撞器在检测碰撞的时候只计算XY轴忽略Z轴。
2D Collider和Rigidbody都能设置物理材质，物理材质应用优先级是 2D Collider指定的材质>2D Rigidbody指定的材质>Physics2D窗口指定的物理材质>Unity默认的值。子物体如果没有设置材质，则会继承父物体Rigidbody指定的材质。
在ProjectSettings->Physics2D可以指定全局2D物理材质，一般的实践都是在Collider上指定，有一些子物体需要的时候才用Rigidbody指定
Dyanmic（常规运动和碰撞的对象
Static（不动不受力但是需要碰撞检测的对象，碰撞器和所有的其他碰撞器检测，但它只能和Dyanmic刚体进行碰撞检测
Kinematic运动学类型 （通过API移动不受力的作用但是要进行碰撞检测
自带的碰撞器，粗糙点的，人物一般用胶囊碰撞器。
再就是边界碰撞器可以自己编辑；复合碰撞器会统合子对象所有的碰撞器作为统一的碰撞检测，复合碰撞器一定是要配合刚体使用，GeometryType可以规定碰撞器是不是实心的。
物理材质和3D中的材质参数一样，摩擦力和弹力系数，计算的时候是两个物体的材质系数一块计算的
Constant Force组件可以添加恒定力，效果类似于每帧AddForce，但是应用场景上不太一样。
首先需要在Collider中开启UsedByEffector并且勾选Trigger才能使用效应器
[ ⚠️Warning ] 效应器的局限性
效应器其实也是写好代码的组件，本质还是施加力，如果功能有限不符合项目要求不要犹豫，自己写
原理是固定时间间隔在一个Sprite数组中切换当前Sprite，就可以达到2D帧动画的效果。正常创建是把序列Sprite创建到Anime中，可以修改此anime的Inspector->Debug可以修改动画的帧率，记得如果修改帧率一定要把原先的动画帧删除再拖新的进去，否则可能会出现丢帧问题。创建的帧动画可以直接在状态机中使用。
其实这个anime的原理也是固定切换Sprite，它默认只能驱动SpriteRenderer,但是你可以把动画挂到UI的Image上然后在关键帧里直接更改属性拖进序列去就可以驱动UI播放帧动画。
利用3D美术骨骼的原理进行制作，为每个部位绑骨骼，性能换内存节省资源。2018后用的方案是2D Animation，先在PackageManager安装。
在SpriteEditor->SkinningEditor编辑骨骼。编辑器中双击选中图片，PreviewPose不会真正影响骨骼，可以预览。 骨骼可以从根部创建，父骨骼动会带动子骨骼。
绑完骨骼就进行Geometry蒙皮，一般是先自动生成再手动调整细节，蒙皮的点越多越占用性能，也会越精细。
调整完蒙皮下一步是设置权重，蒙皮自动生成的时候自动会产生权重，即受骨骼影响大小
注意这几个参数
最后给Scene中的Sprite添加SpriteSkin组件，生成一下骨骼就可以在动画中使用它了，图集的骨骼编辑好导入之后，先建立一个空的父对象，挂Sprite子对象，可以直接场景上编辑父子关系，2D对象一般把中心位置放在脚下。
psb文件和psd都是PS的原生文件格式，unity中推荐使用psb格式导入ps的素材需要先安装Window->PackageManager->2DPSDImporter
一般来说ImportHiddenLayers不勾选，隐藏图层美术留着不导入的；UseLayerGroup一般也不勾选
ImportMode默认Individual Sprites (Mosaic)每个图层会被当作独立的 Sprite 导入，MosaicPadding一般设置1-8不要设置0，在将多个图层合成一张 Mosaic 贴图时，它们之间的间隔像素数，防止图集边缘出现“图像溢出”或采样错误（通常在缩放、模糊、移动时容易出现）
反向动力学IK（Inverse Kinematics）正向动力学FK（Forward Kinematics）正向动力学就是父骨骼带动子骨骼摆动，2022.2后IK已经包含在2DAnimation里面
添加IK Solvers的模式三种 Chain (CCD) 可以自定义影响N个关节点，但不能反向；Chain (FABRIK) 同样可以自定义影响N个关节点，但与CCD不同的是，它可以反向计算；Limb 只会影响3个关节点。
为Sprite添加一个空的父对象，在这个父对象上挂载IK Manager2D组件，添加Solver，此时会在此父对象下生成一个Solver对象；在每个想要被IK控制的骨骼末端位置放置一个子对象。把末端的物体拖到生成的Solver的Effector上，生成的新对象就会牵引着骨骼动。
CCD模式不能直接180度往上拉，FABRIK可以。Limb一般给四肢用，位置不对可以Flip反向，使用此IK的时候，只改变身体的骨骼保持IK的点不动，可以方便的制作idel动画。使用IK点可以使动态动画瞄准某个地方或者动态的生成拾取等动画。
2D换装的实现，在psb中把对应位置的装备都做好，然后都隐藏，需要哪个显示哪个。在SpriteEditor->SkinngEditor->Visibility->Sprite中可以给同部位的装备打Category，一般设置同部位Category相同。
此时场景的psb的对象下SpriteLibrary关联了SpriteLibraryAssets记录类别分组信息，在对应要换装部位的物体上自动挂载SpriteResolver组件选择使用什么装备，换装会自动依赖骨骼。
Csharp
public class TestSpriteResolver : MonoBehaviour
{
public SpriteResolver sr;
private Dictionary<string, SpriteResolver> equipDict = new Dictionary<string, SpriteResolver>();
void Start()
{
SpriteResolver[] srs = this.GetComponentsInChildren<SpriteResolver>(); // 递归查找所有部位的SpriteResolver
for (int i = 0; i < srs.Length; i++)
{
equipDict.Add(srs[i].GetCategory(), srs[i]); // 存储当前的 类别名:SpriteResolver组件
}
ChangeEquipment("Cask","CASK 1"); // 把CASK部位切换成CASK 1
}
void ChangeEquipment(string category,string item) // 封装一下
{
if (equipDict.ContainsKey(category))
{
equipDict[category].SetCategoryAndLabel(category,item);
}
}
}图片都在一个psb下的时候，图集会很大，所以大的时候需要在不同psb中制作换装。在制作psb的时候，制作多套psb隐藏某些图层，某一套只保留本体，其他的多套只保留装备，换一套叠加就换了一套装备。
注意 不同文件的骨骼信息必须统一，所以直接复制骨骼到各个套装 PreviewPose选中需要复制的骨骼，然后CopyRig，不要关掉窗口选择新的psb PasteRig。就复制过去了。
手动创建SpriteLibraryAssets，编辑Inspector；给根对象添加SpriteLibrary组件，关联SpriteLibraryAssets文件；在想要换装的部位添加SpriteResolver，然后就可以看到换装类别了。代码上面的就能重复使用了。
当换装的内容特别多的时候，放一起图集会越来越大，有些移动设备不支持太大图集。
这一节的东西基本都是美术类的直接去Unity中摸的多了就会了，记的东西不多
收费跨平台主流2D动画方案，三个主流引擎都支持，官网在这。程序会用就行，不用制作。下载安装导入不多bb，动画都是用Spine制作完之后导出，然后扔到引擎中使用。
Spine导出的资源文件夹下（官网建议使用二进制导出因为性能更好）
.json 文件：骨骼结构动画数据等.png 文件：使用的图集.atlas.txt 图片在图集中的位置信息，定位和提取具体的贴图_Atlas 文件是材质和.atlas.txt文件的引用配置文件，用于管理图集资源_Material 材质文件_SkeletonData 骨骼动画文件，关联了.json文件和_Atlas资源。 最重要的是_SkeletonData文件，拖到场景中就可以创建。注意_SkeletonData的参数:_SkeletonData创建的选项，第一种是挂载SkeletonAnimation组件，第二是挂载SkeletonMecanim+Animator使用状态机控制。Csharp
public class SpineTest : MonoBehaviour
{
private SkeletonAnimation sa;
[SpineAnimation] // 标明下面的属性是存储动画的，在这Editor里指定
public string JumpAnimation;
// 与上面同理
[SpineBone] // 骨骼
public string boneName;
[SpineSlot] // 插槽
public string slotName;
[SpineAttachment] // 附件
public string attachName;
void Start()
{ sa = GetComponent<SkeletonAnimation>();
sa.loop = false; // 需要先停止动画循环
sa.AnimationName = "jump"; // 再进行动画绑定
// trackIndex 默认一般0就可以，也不知道为啥
sa.AnimationState.SetAnimation(0, JumpAnimation,false); // 不循环直接播放jump动画 和上面两句等效
sa.AnimationState.AddAnimation(0, "jump",false,0); // 不循环 延迟0s 添加junp到播放队列
sa.skeleton.ScaleX = -1; // X轴反转
sa.AnimationState.Start += (t) =>
{
Debug.Log("动画开始播放"+sa.AnimationName);
}; sa.AnimationState.End += (t) =>
{
Debug.Log("动画中断或清除"+sa.AnimationName);
}; sa.AnimationState.Complete += (t) =>
{
Debug.Log("动画播放完成"+sa.AnimationName);
}; sa.AnimationState.Event += (t,e) =>
{ // 此自定义事件 做动画的时候在Spine中定义的这里只用
Debug.Log("触发自定义事件"+sa.AnimationName);
};
Bone b = sa.skeleton.FindBone(boneName); // 可以控制骨骼旋转，牵引IK等
sa.skeleton.SetAttachment(slotName,attachName);// 设置插槽的附件，达成换装的效果
}
}拖进去的时候使用SkeletoGraphic就可以挂载UI的Canvas下在UI中使用了。
#todo 这里以后要再学一学，C#中的委托和Unity中委托的异同点
Unity 额外提供了 UnityEvent，它是 System.Delegate 的封装，主要用于与 Inspector（检查器）交互，支持序列化，可以在 Unity 编辑器中直接绑定回调 Unity 的事件生命周期管理 Unity 提供了 Start(), Update(), OnDestroy() 等生命周期方法，而 C# 传统的委托需要手动管理生命周期。GC（垃圾回收）影响 Unity 的 UnityEvent 是基于 List<Delegate> 而非 C# 的 MulticastDelegate，因此不会像 C# 事件那样造成隐式的 GC 压力（捕获 this 时的内存泄漏风险较低）
订阅GC，订阅泄露
[ 📝Note ] 柯里化概念复习
柯里化（Currying）是一种将接受多个参数的函数转换成接受一个单一参数的函数，并且返回接受余下参数的函数的技术。这种技术由逻辑学家Haskell Curry提出，因此得名柯里化。
假设有一个函数 f(a, b, c)，经过柯里化处理后，它会被转换成 f(a)(b)(c) 的形式。
反柯里化（Uncurrying）是柯里化的逆操作，它将嵌套的函数转换为一个接受多个参数的函数。反柯里化可以使得嵌套的单参数函数变得更易用，特别是在需要处理多个参数的情况下。
假设有一个柯里化函数 f(a)(b)(c)，经过反柯里化处理后，它会被转换成 f(a, b, c) 的形式。
线程其实正常的起就可以，一般是会把密集的计算或异步IO，线程没法直接传递结果，一般会声明公共的缓冲区，由untiy周期函数尝试去拿，拿到了就是计算完了。
启动一个协程函数（即带有 IEnumerator 返回类型的函数）， 必须通过 StartCoroutine 直接调用只会执行方法中的同步部分 ，而不会处理 yield return 语句或等待异步操作完成。IEnumerator Start() 可以自动转换为异步执行，其他的生命周期函数不可以
其实就可以直接搞生产消费者那套了
[ ⚠️Warning ] 线程一定要注意
千万别Join，Unity编辑器本质也是通过反射调用的C#，如果在生命周期里Join整个程序会卡住。
所以线程用完一定要关闭！！！否则线程就会一直开启直到进程关闭
子线程无法访问Unity主线程内容中的东西
Csharp
void Start()
{
Thread t = new Thread(() => TestThread());
t.Start();
}
private void TestThread()
{
int count = 0;
while (true)
{
count += 1;
Thread.Sleep(1000);
Debug.Log($"TestThread print {count}");
this.GetComponent<Collider>();// 这里尝试访问住线程的对象报错了！
}
}也可以使用线程池，频繁创建删除线程时提高性能节约内存，但不能控制线程池中线程的执行顺序，也不能获取线程池内线程取消/异常/完成的通知
Task是基于线程池的改进。 #todo 练习使用 C#多进程 Unity中和C#中的线程池 Task async和await 进阶课3C系列知识14-17集和自己补充 Unity中的协程通常在一段时间内执行某些任务或在帧之间分配工作，在Update()⽅法之后LateUpdate()⽅法之前调用协程通过 IEnumerator 接口和 StartCoroutine 方法来实现。
IEnumerator接口类型，使用yield return。Csharp
void Start()
{
Coroutine cor=StartCoroutine(AsyncDemo(10)); // 去执行一个协程
StopCoroutine(cor); // 结束此协程调用
StopAllCoroutines(); // 停止掉此脚本此脚本此脚本协程池里面所有协程
// StartCoroutine(AsyncDemo(10)); // 也可以这样,但是这样不知道在哪里用了几次。
// 所以建议直接不要这样用，做一件事最好的方法有且仅有一个
}
public IEnumerator AsyncDemo(int num) // 协程的固定返回类型
{
Debug.Log("wait for return ");
yield return new WaitForSeconds(3f); // 3s之后返回，有很多不同的返回函数，用到再看
Debug.Log("done return 1s");
yield return null;
Debug.Log($"done next return , out {num}");
transform.position = new Vector3(10, 10, 10); // 做一次位移
yield return AsyncDemo2(); // 协程是可以嵌套的
}
public IEnumerator AsyncDemo2() // 利用协程做动画，以及协程嵌套，协程本质就是一个函数栈暂停，控制权移交
{
Debug.Log("start async2");
while (true)
{
transform.Rotate(new Vector3(10,0,0)); // 调整角度，配合协程达到旋转的效果，不过这个旋转不是平滑的
// 这里可以用while true执行
yield return new WaitForSeconds(0.5f); // 0.5秒返回一次
}
}运行结果
[22:40:01] wait for return
[22:40:04] done return 1s
[22:40:04] done next return, out 10
[22:40:04] start async2yield返回的特殊方法
yield return null/数字 和 yield return WaitForSeconds：在满足条件后的下一帧 Update 和 LateUpdate 之间执行yield return WaitForFixedUpdate：在 FixedUpdate 和碰撞检测相关函数之后执行(物理更新后)yield return WaitForEndOfFrame：在摄像机和GUI渲染完成后FixedUpdate 之后执行yield break：立即结束协程，协程对象会变nullUpdate 和 LateUpdate 之间执行IEnumerator看。[ 📌Tip ]
Task的本质上是起了新线程，Task.Delay完全不受TimeScale影响。
MonoBehaviour中提供了延迟调用函数的方法Invoke InvokeRepeating CancelInvoke (参数都简单易懂
延时执行只能无参，而且只能执行本脚本中的对象，但是可以先获得，再通过函数或者Action包一下执行。Invoke即为调用，Invoke多次会调用多次，但是CancelInvoke是按照函数签名去取消的，也就是说会把该函数的调用全都踢出队列取消掉。
注意 对象或脚本失活不会影响延迟函数调用；但是对象或脚本销毁移除，就延迟函数不会执行了 如果想要用失活激活控制，可以放到Enable和Disable中控制
Csharp
void CurryingDelyDemo(string s)=>Debug.Log($"be Invoked {s}");
public void InvokeDemo()=>Debug.Log("be Invoked");
public void CalcelInvokeDemo()
{
Debug.Log("Invoke is Canceled");
CancelInvoke("InvokeDemo");
}
void Start() // GameObject加载完毕后所有的Awake执行完，的第一帧执行一次
{
Action myInvokeDemo = () => CurryingDelyDemo("Hello, World!");
Debug.Log("Object start successfully Complete");
// 定时任务
Invoke("InvokeDemo",3f); // 3秒(浮点)后通过反射来执行函数
InvokeRepeating("InvokeDemo",2f,3f); // 从调用的2秒后每3s执行一次
Invoke("CalcelInvokeDemo",10f); //10秒(浮点)后通过反射来执行取消
Invoke(myInvokeDemo.Method.Name,3f); // 通过委托的闭包传递参数
}常用的替代原生的异步任务库，其实是第三方插件。0GC，集合了原生async和unityCoroutine的优点。虽然异步的原理都是状态机但是实现的结构不太一样。看文档安装GitHub - Cysharp/UniTask
Debug模式下Unitask的起停性能差不多比原生协程强40%-50%，Release模式是原生协程的8-10倍左右。
unitask使用await等待dotween动画需要开启一个宏UNITASK_DOTWEEN_SUPPORT。
[ 📌Tip ]
首先来嘱咐一下异步相关的问题，无论是使用任意一种异步方法，实际上也是在主线程中执行的，async实际上只是标识了可以使用异步方法，但是如果在async中调用同步方法依旧会阻塞主线程。所以建议使用await异步方法
我看的是唐老师和游戏石匠的视频代码，用法很全面了，不过最好去下载一下石匠的执行一下对着理解，代码太多不放了打了注释直接去项目里面看吧。
实践建议主线程只做渲染、输入、物理,耗时逻辑全异步
condition() 检查委托调用 + 布尔判断，成本非常小，如果条件一直不触发那就一直监听Unitask<T>,WhenAny返回的是int index，代表哪个最先完成的UniTask但是UI 事件回调要求是void所以用async UniTaskVoid代替 UnityEvent）要求的签名是 UnityAction如果你想直接用异步方法会陷入回调地狱，所以用UniTask.UnityActionCalc().Forget();可以在同步方法中调用异步函数但返回值必须是UniTask或者UniTaskVoid，可以使用Calc().AsUniTask().Forget();强行忽略，Forget的异常只能全局捕获UniTaskCompletionSource产生的token是可以复用的。UI特有的事件转换为Unitask：
ForEachAsync(value,index)去异步迭代操作，相当于IEnumerator的非阻塞迭代，每次触发异步操作的时候迭代一次。但是里面的操作是阻塞的，注意千万别在里面搞骚操作卡住整个playerloopasyncEnumerable可以和其他的迭代器方法结合起来，过滤倒序等等更加灵活OnClickAsync是unitask为Button扩展的方法，可以在此处等待Button被click，下拉列表输入框的事件都可以转换OnClickAsAsyncEnumerable在C#8之后才支持，里面的操作支持异步，如果里面的await操作没有完成，即便触事件迭代器也不会响应，使用.Queue().OnClickAsAsyncEnumerable()可以先塞队列里不丢弃OnClickAsync等待，第一次点击await，第二次点击不await了，把第二次点击和超时的Unitask放入WhenAny，判断哪个先完成OnClickAsAsyncEnumerable转换为异步迭代器，在迭代器中await 等待。值类型封装异步可迭代类型并订阅使用：
AsyncReactiveProperty封装异步迭代对象，可以达到类似于MVVM的效果。 ForEachAsync的时候，会根根据当前值立即触发一次迭代，如果使用asyobj.WithoutCurrent()再ForEachAsync可以忽略当前值获得冷启动的效果MonoBehaviour事件输入：
GameObject.transform.GetAsyncCollisionEnterTrigger把Collision转化为异步迭代事件 UniTaskCompletionSource<Collision>source.TrySetResult(collision);int result = await UniTask.WhenAny(waitAutoDestroy, source.Task); result=1的时候进行处理Application.dataPath是总的工程目录文件夹Assets 的路径，在构建之后并不直接暴露给应用程序不能直接访问，一般只在开发阶段用用，也不保证跨平台一致性Resources资源文件夹直接使用Resources类读取资源。Resources可以在任意层级任意地方，但必须在Assets文件夹下，多个Resources会被合并起来。 prefab_cube = Resources.Load<GameObject>("Perfabs/s2");即可加载(非实例化仅加载对象到内存)。BillingMode.jsonUnity内购API自动生成的配置文件，构建时指定目标应用商店，以便在运行时加载正确的支付插件。Editor中使用 UnityPurchasingEditor.TargetAndroidStore() 选择目标商店时，Unity 会自动生成或更新该文件Assets/StreamingAssets，使用Application.streamingAssetsPath;获得 string path = Path.Combine(Application.streamingAssetsPath, "netConfig.json");读取其中资源StreamingAssets 中的文件进行压缩或优化，适合存放媒体、配置文件、游戏内语言包、地图数据等静态数据persistentDataPath持久数据文件夹Application.persistentDataPath获得使用在运行时可读写，动态下载或者游戏中生成的东西存储，游戏存档经常放里面Plugins插件文件夹 放第三方SDK的Editor编辑器文件夹 使用Application.dataPath+"/Editor"拼接，一般不获得；开发编辑器的时候脚本放里面；不会被打包 using UnityEditor被打包到runtime的时候会报错StandardAssets默认资源文件夹 Unity自带的文件都放这个文件夹，代码和资源优先被编译，一般不获得。UnityWebRequest不仅可以请求web还可以请求本地文件，但路径必须带file://，Win/Mac编辑器里运行时对本地绝对路径做了兼容，最佳实践就是直接全加上file://。
实际上在Android和iOS的streamingAssetsPath被原样打包进了包里，用unity才能读到其他方式没权限拿包里的东西。
| 读取本地路径 | persistentDataPath | persistentDataPath | streamingAssetsPath | streamingAssetsPath |
|---|---|---|---|---|
| 读取方式 | UnityWebRequest | C#文件读取 | UnityWebRequest | C#文件读取 |
| PC | 加 file:/// | 无需处理 | 加 file:/// | 无需处理 |
| Android | 加 file:/// | 无需处理 | 加 jar:file:// | 不可用 |
| iOS | 加 file:/// | 无需处理 | 加 file:/// | 无需处理 |
再就是使用AB包的方式，放到任意文件系统能访问的位置即可加载。
使用 Resources.Load<T>("Name",[typeof(TextAsset)]) 同步加载资源，也可以指定类型或者传泛型。默认加载出来的类型为Unity.Object 可能需要类型转换
[ ⚠️Warning ] 注意文件名
资源文件不要带文件后缀名，最好也不要带特殊字符，而且文件名是大小写敏感的
常见类型
Resources加载到内存后会存在缓存区，多次加载不会重复加载，只会重复在缓存区中查找也会损耗一点性能。Resources.LoadAsync会新起一个线程进行加载，至少要等到下一帧才能拿到结果。Csharp
Texture TargetTexture;
void Start()
{
/* 使用线程加载 */
// ResourceRequest Rq = Resources.LoadAsync<Texture>("Picture/t"); // 该类型包含Action对象
// Rq.completed += LoadDone; // 加载完之后通过回调通知执行
/* 使用协程加载 */
Coroutine cor=StartCoroutine(LoadTexture());
}
private void LoadDone(AsyncOperation op)
{
TargetTexture = (op as ResourceRequest).asset as Texture;
print("Loading Done");
}
IEnumerator LoadTexture()
{
ResourceRequest Rq = Resources.LoadAsync<Texture>("Picture/t");
yield return Rq; // 协程调度器会监控 Rq.isDone 的状态 Rq.priority，完事才执行下面的
while (!Rq.isDone) // 也可以手动监控
{
print($"porcessing {Rq.priority}");
yield return Rq;
} TargetTexture = Rq.asset as Texture;
}
public void OnGUI()
{
if (TargetTexture != null)
{ print("Draw texture");
GUI.DrawTexture(new Rect(0,0,200,100), TargetTexture);
}
}资源必须是通过 Resources.Load 加载的才能卸载，使用Resources.UnloadAsset(oldTexture);卸载，但是不能卸载GameObject对象即使没有实例化。
使用Resources.UnloadUnusedAssets 卸载所有未被引用的资源，此操作是异步的，会遍历所有资源并检查引用计数性能消耗很高，一般搭配GC.Collect()在过场景的时候使用。 某个资源正在被场景中的对象使用（例如一个纹理正被某个材质使用），卸载它可能导致渲染异常或崩溃
场景使用静态类UnityEngine.SceneManagement.SceneManager，需要引入命名空间。能够直接加载的场景需要提前添加到 菜单->File->BuildSettings->Scenes in Build 中，注意这个里面场景有序号。
然后就可以直接SceneManager.LoadScene("NextScene") 加载场景(即便BuildSetting中是带路径的也只用名字就行)，一般最常用的就是通过名字加载,GameObject.DontDestroyOnLoad(gameObject)挂载者自己在场景切换的时候不销毁
退出游戏使用Application.Quit(),打包发布出去才行，编辑模式下没用。(Application类可以获得很多和游戏相关的属性，比如游戏是否在运行isPlaying
加载的时候Unity会删除本场景上的所有对象然后读取下一个场景的东西，东西比较多的时候就耗时多。
异步加载场景SceneManager.LoadSceneAsync("NextScene")返回值和资源异步加载一样是AsyncOperation，可以使用complete事件绑定回调。常用来加载空场景然后使用指定的地图编辑器配置文件生成新场景的内容
Csharp
void Start()
{
AsyncOperation loading=SceneManager.LoadSceneAsync(1);
/* 注意这里，理论上这里加载完后就销毁，但是这个函数被回调引用，引用计数不会销毁它，所以能继续执行 */
loading.completed += (AsyncOperation a) => print("场景2加载完毕");
}
IEnumerator LoadScene2()
{
print("Loading Scene 2");
GameObject.DontDestroyOnLoad(this.gameObject); // 这种操作应该提前操作，Unity切换场景yield完成的时候就已经切完了，涉及到旧场景的对象放在yield return后是不安全的
yield return SceneManager.LoadSceneAsync(1);
/* 这样下面的语句就会执行，否则场景销毁对象也已经被销毁这里就不会被执行。 */
print("Loading Scene 2 done");
/* 这里就可以加过渡和进度条等，按照你想的进度去做 */
}
private float time = 0;
void Update()
{
time += Time.deltaTime;
if (time > 2)// 这里只演示，其实不该在Update里做
{
StartCoroutine(LoadScene2());
}
}鼠标使用公共类Cursor管理，如果你不想鼠标变形就找个一样大小的图片，最好把这个素材的Inspector面板的类型设置为Cursor
Csharp
Cursor.visible = false; // 显不显示
Cursor.lockState = CursorLockMode.Locked; // None不限制,Locked锁在屏幕中心还会被隐藏,Confined缩在游戏窗口
Cursor.SetCursor(cursor_texture, Vector2.zero, CursorMode.Auto); // 一个Texture2d 偏移量 自动管理。持久话键值对，{string:[int string float]} 默认是游戏结束才落盘，如果崩溃就丢了，其实就是个类型支持不全的字典。
存到哪，在BuildSettings->PlayerSettings->CompanyName;ProductName设置。
\HKCU\Software\[CompanyName]\[ProductName]/data/data/包名/shared_prefs/pkg-name.xml/Library/Preferences/[应用ID].plistCsharp
void Start()
{
PlayerPrefs.SetInt("Test1", 10);
PlayerPrefs.SetFloat("Test2",0.5f);
PlayerPrefs.SetString("Test3","ttttt");
PlayerPrefs.Save();// 落盘
PlayerPrefs.DeleteKey("Test1");
// 如果读取的时候对应的类型错误 或者没有这个键，则会返回读取类型的默认值
print(PlayerPrefs.GetInt("Test1", 1)); // get的时候和dict一样可以获取默认值
print(PlayerPrefs.GetFloat("Test2",1f));
print(PlayerPrefs.GetString("Test3","NoValue"));
PlayerPrefs.DeleteAll(); // 全清除，测试常用
if(PlayerPrefs.HasKey("Test1"))print("Test1 有东西！");
}这几个不是Unity自带的，C#直接看的书，有关序列化的坑也在这里了。
主流的这四个newtonsoft.json, System.Text.Json,fastjson , jsondotnet，Unity自带的JsonUtility（非常不好用，只看第一个就行剩下俩碰到再说
直接上代码
Csharp
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
namespace PlayGround;
#region NewtonSoft.Json基础用法
class Student
{
public int Id { get; set; }
public string? FullName { get; set; }
public int Age { get; set; }
public string? Address { get; set; }
public double GPA { get; set; }
}
public class Play1
{
public string S_string = """
{
"Id": 1,
"FullName": "Jhon",
"Age": 20,
"Address": "翻斗花园",
"GPA": 3.5
}
""";
private JsonSerializerSettings _settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented, // 使用缩进
ContractResolver = new DefaultContractResolver
{
// NamingStrategy = new DefaultNamingStrategy()
NamingStrategy = new SnakeCaseNamingStrategy() // 蛇形
// NamingStrategy = new CamelCaseNamingStrategy()// 大驼峰
// NamingStrategy = new KebabCaseNamingStrategy() // 烤-串-命-名
},
NullValueHandling = NullValueHandling.Ignore,// 序列化遇到空值会跳过去掉这个属性
StringEscapeHandling = StringEscapeHandling.EscapeNonAscii, // 会把非ascii进行unicode编码
TypeNameHandling = TypeNameHandling.Auto,// 使用All可以强制带上序列化和反序列化的类型名。
};
public void Run()
{
Student s = new Student
{
Id = 1,
FullName = "Jhon",
Age = 20,
Address = "翻斗花园",
GPA = 3.5
};
string jsonStr = JsonConvert.SerializeObject(s); // 默认是一行压缩展示
jsonStr=JsonConvert.SerializeObject(s,_settings); // 自动换行
Console.WriteLine(jsonStr);
Student s1 = JsonConvert.DeserializeObject<Student>(S_string); // 设置序列化和反序列化都能用
Console.WriteLine(s1.FullName);
}
}
#endregion
#region JsonPopulateObject用法
public class Person2
{
public string Name { get; set; }
public int Age { get; set; }
public List<string> Hobbies { get; set; }
public override string ToString() => $"Name:{Name},Age:{Age},Hobbies:{string.Join(",", Hobbies)}";
}
public class Play2
{
private JsonSerializerSettings _settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented, // 使用缩进
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy() // 蛇形
},
NullValueHandling = NullValueHandling.Ignore,// 序列化遇到空值会跳过去掉这个属性
StringEscapeHandling = StringEscapeHandling.EscapeNonAscii, // 会把非ascii进行unicode编码
ObjectCreationHandling = ObjectCreationHandling.Replace // 使用PopulateObject如果是单独项则直接替换。如果是list就会append进来，指定Replace也会直接替换
};
private string s="""
{
"name": "Jack",
"age": 35,
"hobbies": [
"Chinese",
"English",
"Write"
]
}
""";
public void Run()
{
Person2 p = new Person2
{
Name = "Jack",
Age = 20,
Hobbies = new List<string> { "Play", "Read", "Write" }
};
Console.WriteLine(JsonConvert.SerializeObject(p,_settings));
JsonConvert.PopulateObject(s, p,_settings);// 读取json字符串，然后更新当前的对象
Console.WriteLine(JsonConvert.SerializeObject(p,_settings));
}
}
#endregion
#region 提供的Attributes
// MemberSerialization.OptIn 白名单模式，写了JsonProperty的才要
// MemberSerialization.OptOut 黑名单模式，写了JsonIgnore的才不要
// MemberSerialization.Fields 很奇怪，会把封装到IL的真实属性带出来？
[JsonObject(MemberSerialization.Fields),]
public class Person3
{
[JsonProperty("create_at1")] // 我就想序列化,还指定自定义名称！
private readonly DateTime CreateAt = DateTime.Now;
public Guid Id { get; set; }
public string Name { get; set; }
public int Age { get; set; }
public List<string> Hobbies { get; set; }
public event EventHandler? OnPropertyChanged;
[JsonIgnore] // 如果我不想序列化
public string? Description => $"Name:{Name},Age:{Age},Hobbies:{string.Join(",", Hobbies)}";
}
public class Play3
{
Person3 p = new Person3
{
Id = Guid.NewGuid(),
Name = "Jhon",
Age = 10,
Hobbies = new List<string> { "Funk", "Music" }
};
private JsonSerializerSettings _settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented, // 使用缩进
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy() // 蛇形
},
StringEscapeHandling = StringEscapeHandling.EscapeNonAscii, // 会把非ascii进行unicode编码
};
public void Run()
{
Console.WriteLine(JsonConvert.SerializeObject(p,_settings));
}
}
#endregion
#region 自定义的Converter序列化器
class Person4
{
[JsonProperty, JsonConverter(typeof(DateTimeFormateConverter))]
private readonly DateTime CreateAt = DateTime.Now;
public Guid Id { get; set; }
public string Name { get; set; }
public IntWapper _Age { get; set; } // 直接用会相当于嵌套对象一样的效果"_Age":{"Value":10}
// public int Age { get=>_Age.Value; set=>_Age.Value = value; } // 使用自定义的JsonConverter可以不用单独写这东西
[JsonConverter(typeof(StringEnumConverter))] // 可以让序列化出来的Enum使用名字而不是数字
public Gender Gender { get; set; }
[JsonConverter(typeof(StringEnumConverter))]
public WorkDays WorkDays { get; set; }
public List<string> Hobbies { get; set; }
}
public class Play4
{
Person4 p=new Person4()
{
Id = Guid.NewGuid(),
Name = "Jhon",
_Age = new IntWapper(10),
Gender = Gender.Male,
WorkDays = WorkDays.Monday |WorkDays.Tuesday|WorkDays.Wednesday|WorkDays.Saturday|WorkDays.Friday, // 使用二进制表示哪天干活
Hobbies = new List<string> { "Funk", "Music" }
};
public void Run()
{
string j = JsonConvert.SerializeObject(p,Formatting.Indented);
Console.WriteLine(j);
}
}
enum Gender
{
Male,
Female
}
[Flags] // 让一个枚举值可以同时表示多个状态的组合。序列化和 ToString() 时，自动输出组合名称。
public enum WorkDays
{
Monday=1,
Tuesday=2,
Wednesday=4,
Thursday=8,
Friday=16,
Saturday=32,
Sunday=64
}
class DateTimeFormateConverter : IsoDateTimeConverter // 自定义时间的序列化
{
public DateTimeFormateConverter()
{
DateTimeFormat = "yyyy-MM-dd";
}
}
[JsonConverter(typeof(IntWapperConverter))] // 所有使用IntWapper类的属性在自动序列化的时候都会走自定义的Converter
class IntWapper
{
public IntWapper(int value)
{
this.Value = value;
}
public int Value { get; set; }
}
class IntWapperConverter : JsonConverter
{
public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
serializer.Serialize(writer, ((IntWapper)value).Value); // 序列化的时候怎么做
}
public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
return new IntWapper(Convert.ToInt32(reader.Value)); // 反序列化的时候怎么做
}
public override bool CanConvert(Type objectType)
{
return typeof(IntWapper).IsAssignableFrom(objectType); // 能不能被序列化
}
}
#endregion
#region 序列化的HOOK函数
public class Person5
{
public string Name { get; set; }
public int Age { get; set; }
public List<string> Hobbies { get; set; }
public event EventHandler? OnPropertyChanged;
[OnSerializing]
internal void OnSerializingMethod(StreamingContext context)
{
}
[OnSerialized]
internal void OnSerializedMethod(StreamingContext context)
{
}
[OnDeserializing]
internal void OnDeserializingMethod(StreamingContext context)
{
Console.WriteLine("Deserializing!");
Hobbies?.Clear(); // 反序列化的时候先把原来的列表清掉
}
[OnDeserialized]
internal void OnDeserializedMethod(StreamingContext context)
{
this.OnPropertyChanged+= (sender, e) => Console.WriteLine("属性变化了");
this.OnPropertyChanged.Invoke(this, new EventArgs()); // 调用一下试试
}
}
public class Play5
{
Person5 p = new Person5
{
Name = "Jhon",
Age = 10,
Hobbies = new List<string> { "Funk", "Music" }
};
private string s = """
{
"name": "ahon",
"age": 15,
"hobbies": [
"Chinese",
"Math"
]
}
""";
private JsonSerializerSettings _settings = new JsonSerializerSettings
{
Formatting = Formatting.Indented, // 使用缩进
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new SnakeCaseNamingStrategy() // 蛇形
},
StringEscapeHandling = StringEscapeHandling.EscapeNonAscii, // 会把非ascii进行unicode编码
};
public void Run()
{
Console.WriteLine(JsonConvert.SerializeObject(p,_settings));
JsonConvert.DeserializeObject<Person5>(s,_settings); // 这里应该就会输出日志并且挂上了那个是函数事件
}
}
#endregion
public class Play6
{
private string s = @"
[{
""$schema"": ""http://json.schemastore.org/launchsettings.json"",
""profiles"": {
""Newtonsoft.Json.Tutorial"": {
""commandName"": ""Project"",
""environmentVariables"": {
""ASPNETCORE_ENVIRONMENT"": ""Development"",
""ASPNETCORE_URLS"": ""http://localhost:5000"",
""DOTNET_USE_POLLING_FILE_WATCHER"": ""true""
}
}
}
}]";
public void Run()
{
// var obj = (JObject)JsonConvert.DeserializeObject(s); // 可以一般序列化不指定类型，但是注意Array还是Object
var obj = JArray.Parse(s); //
Console.WriteLine(obj[0]["profiles"]["Newtonsoft.Json.Tutorial"]["commandName"].ToString());
}
}newtonsoft.json官网 需要注意和说明的参数
public 的属性，他不会自动序列化字段，也就是说public int Id;是不行的,要在类上给它加[JsonObject(MemberSerialization.Fields)]或者在字段上加[JsonProperty]List<Person>作为反序列化的泛型，会报错，因为他不知道该使用哪个类，此时用TypeNameHandling = TypeNameHandling.Auto设置去反序列化带$type的json即可识别。如果不开启TypeNameHandling属性他会退化成只填充了 Person 有的字段（如 Name）其余字段（如 Company 或 School）会自动忽略就不报错了。ReferenceLoopHandling = ReferenceLoopHandling.Ignore，unity中打开Window->PackageManager中Add package from name使用com.unity.nuget.newtonsoft-json安装，有时候直接搜搜不到
在Native AOT的场景下，是不支持反射和动态代码生成的，newtonsoft.json使用了大量反射和动态代码生成，所以要使用System.Text.Json的源生成方式调用。 这个就用到再说不搞那么细了。
#todo最下面有全局的Converter可用
文档(中文也有)讲的很明白，我用C#+unity。主要使用流程：写proto的配置文件；使用protoc编译成对应语言的类文件；在工程中引入protobuf库。然后就可以正常序列化发送接收了。
Google官方的protobuf:
C#和unity中引用protobuf库可以自己编译也可以使用别人编译好的dll文件，好像没有跨平台限制兼容unity版本就可以，Unity放Plugins里面。或者github项目中的protobuf/csharp/src/Google.Protobuf文件夹放到Assets里面。protoc命令安装不多说。
shell
protoc --proto_path=StreamingAssets --csharp_out=Scenes/testproto --csharp_opt=base_namespace=example test.proto
protoc --proto_path=StreamingAssets --csharp_out=Scenes/testproto test.proto--csharp_opt=base_namespace=specify_namespace指定此次生成的proto类的命名空间，还有一种方法就是在proto的package关键字中指定多级命名空间以及引用其他命名空间。--proto_path一次性指定多个目录搜索proto文件，按顺序搜索重名的会使用找到的第一个protoc会将消息和字段名转换为首字母大写，并把 串行 小驼峰 转换为 大驼峰。user_name和userName编译后结果都是UserName，此时编译会不通过Csharp
void Start()
{
Example.User user = new User // 和构建类一样去构建
{
Name = "小明",
Email = "j@gmail.com",
Addresses = { new Address()
{
City = "洛杉矶",
State = "LA",
ZipCode = 10000,
Street = "jeans"
} }
};
user.Type = UserType.Member;
Address _addr = new Address
{
City = "纽约1",
State = "NY2",
ZipCode = 10003,
Street = "jeans4"
};
user.Addresses.Add(_addr); // repeated可以当数组用
user.Tags.Add("标记1","值1"); // map可以当字典用
user.Phone = null;// 只有可空类型才允许赋值为空
byte[] data = user.ToByteArray();// 转换为字节数组
Debug.Log($"序列化字节数组长度: {data.Length}");
using (MemoryStream stream = new MemoryStream()) // 使用流序列化
{
user.WriteTo(stream);
Debug.Log($"流长度: {stream.Length}");
}
User parsedUser = User.Parser.ParseFrom(data);// 从字节数组反序列化，也可以直接从流序列化
Debug.Log($"解析用户名字: {parsedUser.Name}");
}反序列化的时候可以从流中读取，Protobuf 本身没有内置消息边界，可以每条消息前写一个 varint 长度前缀，用长连接一边发一边接，读取完指定的长度解析一次。这样可以在一个流里面塞一堆消息。
protobuf官方是从.net3.5开始支持的，社区开发了protobuf-net只能在dotnet内部使用，使用protogen而不是protoc，一般一个项目只用这俩中的一个（新的最好
XmlDocument,XmlTextReader ,Linq常用的三种，一般无脑用XmlDocument和Linq。 基本IO
Csharp
void Start()
{
XmlDocument xml = new XmlDocument();
string xmlPath = Path.Combine(Application.streamingAssetsPath, "TestXml.xml");
string xmlStr = File.ReadAllText(xmlPath);
xml.LoadXml(xmlStr); // 加载字符串为xml
xml.LoadXml(xmlPath); // 按路径直接加载文件
XmlNode root = xml.SelectSingleNode("Root"); // 获取根节点(xml有且仅有一个根节点)
XmlNode nodeName = root.SelectSingleNode("name"); // 通过根节点去获取下面的子节点
print(nodeName.InnerText); // 获取节点文本，默认已经做了CDATA的处理了
XmlNode nodeItem = root.SelectSingleNode("Item");
XmlNodeList ChildNodes = nodeItem.ChildNodes; // 遍历字节点，字节点支持Name和InnerText属性
print(nodeItem.Attributes["id"].Value); // 获取属性值
print(nodeItem.Attributes.GetNamedItem("num").Value); // 也可以这样获取
XmlNodeList friendList = root.SelectNodes("Friend"); // 同名节点 获取列表
print(xml);
}Csharp
void Start()
{
string xmlPath = Path.Combine(Application.streamingAssetsPath, "TestXmlWrite.xml");
XmlDocument xmlDocument = new XmlDocument();
XmlDeclaration xmlDec = xmlDocument.CreateXmlDeclaration("1.0", "UTF-8", ""); // 创建固定版本信息
xmlDocument.AppendChild(xmlDec);// 需要手动添加进去
XmlElement root = xmlDocument.CreateElement("Root"); // 创建根节点
xmlDocument.AppendChild(root);
XmlElement name = xmlDocument.CreateElement("name"); // 创建子节点
name.InnerText = "小明";
root.AppendChild(name); // 需要在对应的节点下Append
XmlElement listInt = xmlDocument.CreateElement("listInt");
for (int i = 1; i <= 3; i++) // 添加多个子节点
{
XmlElement childNode = xmlDocument.CreateElement("int");
childNode.InnerText = i.ToString(); // 内容为下标
childNode.SetAttribute("id", i.ToString()); // 设置id属性
childNode.SetAttribute("num", (i * 10).ToString()); // 设置num属性
listInt.AppendChild(childNode);
}
root.AppendChild(listInt);
xmlDocument.Save(xmlPath);
Debug.Log("------------------------------"); // 写入之后，读取并修改
XmlDocument newXml = new XmlDocument();
newXml.Load(xmlPath); // 读取刚才创建的那个
XmlNode node;
node = newXml.SelectSingleNode("Root").SelectSingleNode("name");
node = newXml.SelectSingleNode("Root/name"); // 直接用路径也可以
XmlNode root2 = newXml.SelectSingleNode("Root");//得到父节点
root2.RemoveChild(node); // 移除子节点方法
XmlElement moveSpeed = newXml.CreateElement("moveSpeed");
moveSpeed.InnerText = "20";
root2.AppendChild(moveSpeed); // 给你想加的加上
newXml.Save(xmlPath);
}运行结果
xml
<?xml version="1.0" encoding="UTF-8"?>
<Root>
<listInt>
<int id="1" num="10">1</int>
<int id="2" num="20">2</int>
<int id="3" num="30">3</int>
</listInt>
<moveSpeed>20</moveSpeed>
</Root>序列化 XmlSerializer 接口提供了钩子，可以让一些内容单独处理逻辑，可以在里面单独处理字典
如果字段为 null这个XML节点会被跳过，空节点都不会生成。如果有需求在IXmlSerializable.WriteXml中自己写。
#todo 其实没搞完上班看这几个自定义API方式的用法区别
Csharp
#define USE_TYPE_1
// #define USE_TYPE_2
// #define USE_TYPE_3
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
using UnityEngine;
// 子节点类
public class ChildNode
{
[XmlAttribute("Test1")] // 序列化为属性
public int test1 = 1;
[XmlAttribute()]
public float test2 = 1.1f;
[XmlAttribute()]
public bool test3 = true;
[XmlIgnore] // 忽略字段，不序列化
public string temp = "不序列化的字段";
}
[XmlRoot("RootNode")] // 指定根节点名字
public class TestXML : IXmlSerializable
{
public int testPublic = 1;
[XmlElement("testPublicRenamed")]
public int testPublic2 = 2;
public string testPublicStr = "我是testPublicStr";
public int[] arrayInt = new int[3] { 1, 2, 3 };
[XmlArray("IntList")] // 列表节点的名字
[XmlArrayItem("Int32")] // 列表内元素节点的名字
public List<int> listInt = new List<int> { 1, 2, 3, 4 }; // 一般列表的序列化
public List<ChildNode> listItem = new List<ChildNode> { new ChildNode(), new ChildNode() }; // 类列表的序列化
private int testPrivate = 3; // 私有成员不会序列化
public Dictionary<int, string> testDic = new Dictionary<int, string>() { { 1, "123" }, { 2, "456" } }; // 直接序列化字典
public XmlSchema GetSchema() => null; // 通常返回 null
#if USE_TYPE_1
// ------------------------ 方式1 直接写serializer------------------------
public void WriteXml(XmlWriter writer) // XmlWriter：提供顺序写XML文档的API
{
new XmlSerializer(typeof(List<int>)).Serialize(writer, listInt); // Serialize：把对象写到writer
new XmlSerializer(typeof(List<ChildNode>)).Serialize(writer, listItem);
writer.WriteStartElement("DictList"); // WriteStartElement：写开始标签 <DictList>
foreach (var kv in testDic)
{
writer.WriteStartElement("Item"); // <Item>
writer.WriteAttributeString("Key", kv.Key.ToString()); // 写属性 Key="1"
writer.WriteAttributeString("Value", kv.Value); // 写属性 Value="123"
writer.WriteEndElement(); // </Item>
}
writer.WriteEndElement(); // </DictList>
}
public void ReadXml(XmlReader reader) // XmlReader：提供只进不退的方式读取XML节点
{
reader.MoveToContent(); // 定位到当前元素的内容（跳过声明/空白）
listInt = (List<int>)new XmlSerializer(typeof(List<int>)).Deserialize(reader); // Deserialize：从XML生成对象
listItem = (List<ChildNode>)new XmlSerializer(typeof(List<ChildNode>)).Deserialize(reader);
testDic.Clear();
if (reader.ReadToDescendant("Item")) // ReadToDescendant：跳到第一个<Item>
{
do
{
int key = int.Parse(reader.GetAttribute("Key")); // GetAttribute：读取属性值
string value = reader.GetAttribute("Value");
testDic[key] = value;
} while (reader.ReadToNextSibling("Item")); // ReadToNextSibling：跳到下一个<Item>
reader.ReadEndElement(); // 离开</DictList>
}
}
#elif USE_TYPE_2
// ------------------------ 方式2 手动写属性/节点 ------------------------
public void WriteXml(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("testPublic"); // <testPublic>
xmlWriter.WriteElementString("Value", testPublic.ToString()); // <Value>1</Value>
xmlWriter.WriteEndElement(); // </testPublic>
xmlWriter.WriteStartElement("testPublicStr"); // <testPublicStr>
xmlWriter.WriteElementString("Value", testPublicStr);
xmlWriter.WriteEndElement();
}
public void ReadXml(XmlReader xmlReader)
{
xmlReader.MoveToContent();
if (xmlReader.MoveToAttribute("testPublic")) // MoveToAttribute：尝试移动到指定属性
testPublic = int.Parse(xmlReader.Value); // Value：当前节点/属性的值
if (xmlReader.MoveToAttribute("testPublicStr"))
testPublicStr = xmlReader.Value;
}
#elif USE_TYPE_3
// ------------------------ 方式3 循环读取NodeType ------------------------
public void WriteXml(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("testPublic");
xmlWriter.WriteString(testPublic.ToString()); // WriteString：写文本内容
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("testPublicStr");
xmlWriter.WriteString(testPublicStr);
xmlWriter.WriteEndElement();
}
public void ReadXml(XmlReader xmlReader)
{
xmlReader.MoveToContent();
while (xmlReader.Read()) // Read：前进到下一个节点
{
if (xmlReader.NodeType == XmlNodeType.Element) // NodeType：当前节点类型（Element/Text/EndElement）
{
switch (xmlReader.Name) // Name：节点名称
{
case "testPublic":
xmlReader.Read(); // 移动到<testPublic>的内容
testPublic = int.Parse(xmlReader.Value); // Value：当前文本节点的值
break;
case "testPublicStr":
xmlReader.Read();
testPublicStr = xmlReader.Value;
break;
}
}
}
}
}
#else
#endif
public class XMLExample : MonoBehaviour
{
void Start()
{
string path = Application.persistentDataPath + "/TestXMLSerialize.xml";
TestXML obj = new TestXML(); // 构造一个默认数据的类
print("XML存储路径：" + path);
// ---------------- 序列化 ----------------
using (StreamWriter writer = new StreamWriter(path)) // StreamWriter有他就打开没有他会新建。
{
XmlSerializer serializer = new XmlSerializer(typeof(TestXML));
serializer.Serialize(writer, obj); // 落盘
}
// ---------------- 反序列化 ----------------
using (StreamReader reader = new StreamReader(path)) // 读不到会System.IO.FileNotFoundException
{
XmlSerializer serializer = new XmlSerializer(typeof(TestXML));
TestXML deserialized = (TestXML)serializer.Deserialize(reader);
print("反序列化 testPublic: " + deserialized.testPublic);
print("反序列化 testPublic2: " + deserialized.testPublic2);
print("反序列化 testPublicStr: " + deserialized.testPublicStr);
print("反序列化 listInt[0]: " + deserialized.listInt[0]);
print("反序列化 listItem[0].test1: " + deserialized.listItem[0].test1);
}
}
}C#内置二进制序列化不多讲直接看API
Csharp
void Start()
{
string path = Application.streamingAssetsPath;
print(File.Exists(path + "/t0.txt"));
FileStream fsc = File.Create(path + "/t1.txt");fsc.Close(); // 注意这个会覆盖已有文件
File.Delete(path + "/t1.dest.txt"); // 不存在不管存在就删
File.Copy(path + "/t1.txt", path + "/t1.dest.txt", true); // 最后参数控制有就覆盖，false则有就报错
File.Replace(path + "/t1.txt", path + "/t1.dest.txt", path + "/t1.back.txt"); // 前俩参数必须存在 第三个参数只备份内容
FileStream fso = File.Open(path + "/t1.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite); // FileMode控制打开时的行为
// 其实上面两个打开的操作占了俩文件描述符
byte[] bytes = BitConverter.GetBytes(999); // 转字节
byte[] sbytes = Encoding.UTF8.GetBytes("测试写字符串数组");
byte[] Lenbytes = BitConverter.GetBytes(sbytes.Length); // 获取字符串数组多长,固定返回一个int4字节
File.WriteAllBytes(path + "/t2.t", bytes);// 这三个不存在就抛错DirectoryNotFoundException
File.WriteAllText(path + "/t3.txt", "我测");
File.WriteAllLines(path + "/t4.txt",new string[]{"a","b"}); // 一行一个写入字符串数组
// 打开文件流的三种方式（茴的四种写法？
FileStream fs1 = new FileStream(path + "/fs1", FileMode.Create, FileAccess.ReadWrite);
FileStream fs2 = File.Create(path + "/fs2",2048); // 相当于一个简化工厂方法，默认 FileMode.Create、FileAccess.Write 只写不读
FileStream fs3 = File.Open(path + "/fs3", FileMode.OpenOrCreate);// 也是相当于工厂方法，需要传 FileMode，可选 FileAccess 和 FileShareif(fs3.CanSeek)print("可寻址");
print(fs3.Length); // 文件流里有多少字节 不可寻址的文件句柄会报System.NotSupportedException: Stream does not support seeking
fs3.Write(Lenbytes,0,Lenbytes.Length); // 字节数组文件指针开始和结束
fs3.Write(sbytes,0,sbytes.Length);
if(fs3.CanSeek)print("可移动文件指针");
if(fs3.CanRead)print("可读");
if(fs3.CanWrite)print("可写");
fs3.Flush(); // 落盘
fs3.Close(); // 关闭描述符
fs3.Dispose(); // 自动fs3.Close()并回收缓冲区和其他资源
// 测试读取
FileStream fs4 = new FileStream(path + "/fs3", FileMode.Open, FileAccess.Read);
Lenbytes = new byte[4]; // 重置
int bytesReadLength = fs4.Read(Lenbytes,0,4); // Read会返回这次读取了多长（字节数）
int _length = BitConverter.ToInt32(Lenbytes);
sbytes =new byte[_length]; // 重置
int offset = 0; // 文件指针
byte[] buffer = new byte[2]; // 每次读取 2 字节
int bytesRead;
print("分块读取：");
while (offset < _length && (bytesRead = fs4.Read(buffer, 0, buffer.Length)) > 0) // 注意按字节读取是怎么读的
{
Array.Copy(buffer, 0, sbytes, offset, bytesRead);// 拷贝读取的数据到目标数组
offset += bytesRead; // 移动文件指针
}
string result = Encoding.UTF8.GetString(sbytes, 0, _length); // 完整读取后，转换为字符串
print("成功读取："+result);
fs4.Dispose();
}Finalize，但是多久才会GC掉是未知的，最好记得关。IOException: Sharing violation on path /Assets/StreamingAssets/t1.txtSystem.NotSupportedException: Stream does not support seekingReadOnlySpan<byte> buffer 是一种 结构化的只读内存视图fs.Write(lenBytes, 0, lenBytes.Length);长度是可以接收Long的，但是超过int范围大小的sbytes.Length会获取报错，使用sbytes.LongLength获取Long类型的大小，读的时候也用Long的长度读Read 或 Write 时从磁盘读取/写入对应部分的数据File.ReadAllBytes() 或 File.ReadAllText()会一次性把整个文件读到内存大文件会 OOM MemoryMappedFile它只把访问的部分映射到内存| FileMode行为 | 文件存在 | 文件不存在 |
|---|---|---|
| Create | 覆盖 | 创建 |
| CreateNew | IOException | 创建 |
| Open | 打开 | FileNotFoundException |
| OpenOrCreate | 打开 | 创建 |
| Truncate | 打开并清空 | FileNotFoundException |
| Append | 只写打开指针移到末尾 | 创建 |
最好记一下每种变量占几个字节;Integral numeric types; Floating-point numeric types
Csharp
void Start()
{
string path = Application.streamingAssetsPath;
Directory.Exists(path+"/dir1");
DirectoryInfo dirInfo = Directory.CreateDirectory(path + "/dir1"); // 可以按照路径递归创建，已存在会直接返回文件夹信息
Directory.CreateDirectory(path + "/dir2");
string[] dirs = Directory.GetDirectories(path); // 返回绝对路径
Directory.Delete(path + "/dir1",false); // 删非空报错，加第二个参数相当于rm -rf 如果某些文件被锁定或无权限，仍然会抛异常
string[] files = Directory.GetFiles(path);
Directory.Move(path + "/dir2",path + "/dir3");// dest已经存在报错
print(dirInfo.Name);// Name文件夹名字；FullName带名全路径；Parent父文件夹名字(根目录返回 null)；Extension点分割的后缀；Root始终返回根目录;
DirectoryInfo parentDir = Directory.GetParent(path + "/dir3"); // 获得目标的父文件夹
DirectoryInfo[] dirsDetail = parentDir.GetDirectories(); // 更详细一些，支持搜索默认*
FileInfo[] filesDetail = parentDir.GetFiles();
print(filesDetail[0].Length); // FileInfo可以获得Length
string filePath = path+"/demo.txt";File.Create(filePath);
string dirPath = path+"/dir3"; // 先创建示例
string combined = Path.Combine(dirPath, "subfolder", "file.txt"); //
print(combined); // 合并后 /Users/jack/code/dotnet/demobase/CoreProject/Assets/StreamingAssets/dir3/subfolder/file.txt 注意后面是怎么合并的
print(Path.GetFileName(filePath)); // demo.txt
print(Path.GetFileNameWithoutExtension(filePath)); // demo
print(Path.GetDirectoryName(filePath)); // /Users/jack/code/dotnet/demobase/CoreProject/Assets/StreamingAssets
print(Path.GetExtension(filePath)); // .txt
print(Environment.CurrentDirectory); // 当前工作目录 unity默认是项目根目录，可以通过更改这个值改掉
print(Path.GetFullPath(@"../demo.txt")); // 返回此路径的绝对路径，依赖当前工作目录/Users/jack/code/dotnet/demobase/demo.txt
print(Path.GetTempPath()); // 系统临时目录
print(Path.GetTempFileName()); // 临时文件（会创建一个空文件）
string newFile = Path.ChangeExtension(filePath, ".log");
print(newFile);
print(Path.IsPathRooted(filePath)); // 判断是否是绝对路径
print(Path.GetRandomFileName()); // 随机文件名，不会真创建(x4z1ab2f.tmp)
}Path.Combine会从第一个绝对路径开始覆盖前面的路径| Path属性 | 说明 |
|---|---|
Path.DirectorySeparatorChar | 当前系统目录分隔符 \ 或 / |
Path.AltDirectorySeparatorChar | 替代分隔符 /（在 Windows 可用） |
Path.PathSeparator | 路径列表分隔符 ; |
Path.InvalidPathChars | 不允许出现在路径中的字符数组 |
Path.MaxPath | Windows 最大路径长度（260 字节，.NET Core 可以超长） |
Csharp
public class BinarySerialize : MonoBehaviour
{
[System.Serializable]
public class Person
{
public string Name = "jack";
public int i = 1;
}
void Start()
{
Person person = new Person();
using (MemoryStream memoryStream = new MemoryStream())
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, person);
byte[] _bytes = memoryStream.GetBuffer(); // 对象的二进制数组拿到可以做很多事
File.WriteAllBytes(Application.streamingAssetsPath + "/person", _bytes);
memoryStream.Close();
}
using (FileStream fileStream = new FileStream(Application.streamingAssetsPath + "/person.cp", FileMode.OpenOrCreate, FileAccess.Write))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(fileStream, person); // 序列化完直接写到一个打开的流中
fileStream.Flush();
fileStream.Close();
}
byte[] bytes = File.ReadAllBytes(Application.streamingAssetsPath + "/person");
using (MemoryStream memoryStream = new MemoryStream(bytes))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
Person personRestore = binaryFormatter.Deserialize(memoryStream) as Person; // 反正传个打开的Stream就行
memoryStream.Close();
print("还原Person：" + personRestore.Name);
}
}
}使用的是内置的BinaryFormatter，类上加[System.Serializable]特性进行序列化
Vector3, Quaternion, Color 等内置 [Serializable] 类型public 或 [SerializeField] 才能被序列化，不支持字典、接口、抽象类、委托、事件、循环引用[NonSerialized] 可以显式排除字段C#中的高性能二进制序列化，不跨语言，dotnet10(unity2021.3+)支持，需要额外安装，定位是替代C#内置二进制序列化，提供了生命周期hook函数。
[MemoryPackIgnore]来移除序列化目标，[MemoryPackInclude]将私有成员提升为序列化目标，所有成员都需要是可以被序列化的不然报错。Csharp
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using MemoryPack;
using System;
public class MemoryP : MonoBehaviour
{
void Start()
{
// 创建测试对象，包含多态引用
User user = new User { Id = 1001, Name = "Jack", Email = "jack@example.com",
Pet = new Dog { Name = "Buddy", HasTail = true } }; // 使用Union特性实现多态
// 预分配缓冲区，实现零分配（我的Mono好像不支持）
byte[] buffer = new byte[1024];
int bytesWritten = MemoryPackSerializer.Serialize<User>(user, buffer);
Debug.Log($"序列化字节长度: {bytesWritten}");
// 反序列化用户对象
User deserializedUser = MemoryPackSerializer.Deserialize<User>(buffer, 0, bytesWritten);
Debug.Log($"反序列化结果: Id={deserializedUser.Id}, Name={deserializedUser.Name}");
// 直接序列化到新分配的字节数组（简便但有内存分配）
byte[] data = MemoryPackSerializer.Serialize<User>(user);
User deserializedUser2 = MemoryPackSerializer.Deserialize<User>(data);
}
}
[MemoryPackable]
public partial class User
{
public int? Id { get; set; } // 支持可空类型
public string Name { get; set; } // 支持字符串
public string Email { get; set; }
public Animal Pet { get; set; } // 多态属性，使用Union特性实现
}
[MemoryPackable] // 使用MemoryPackUnion在抽象基类或接口上保证编译时 Source Generator 生效
[MemoryPackUnion(0, typeof(Dog))] // 使用索引0标识Dog类型
[MemoryPackUnion(1, typeof(Cat))] // 使用索引1标识Cat类型
public abstract partial class Animal
{
public string Name { get; set; }
}
[MemoryPackable]
public partial class Dog : Animal
{
public bool HasTail { get; set; } // 特有属性
}
[MemoryPackable]
public partial class Cat : Animal
{
public int Lives { get; set; } // 特有属性
}Unity内置的可配置的对象可以理解为一个数据模板类，优势是可以直接在Inscpetor中编辑，在Editor下是持久化的，runtime停止之后也是会丢失的。
性能其实没有xml二进制json高
类似MonoBehaviour，需要继承ScriptableObject类，inspector中的可见性和MonoBehaviour一样，直接关联ScriptableObject相当于设置默认值，会记录在对应的.meta文件中
可以注册[CreateAssetMenu()]特性（ScriptableObject特有的）在右键在菜单创建，也可以在方法中调用创建，一般是在菜单栏静态方法里用
右键菜单创建
Csharp
// 参数为创建出来的数据文件默认名字，右键菜单显示名字，排序优先级（升序）
[CreateAssetMenu(fileName ="jackData", menuName ="ScriptableObject/我的数据", order = 0)]
public class MyData:ScriptableObject
{
public int i;
public float f;
public bool b;
public GameObject gobj;
public Material m;
public AudioClip auCliper;
public VideoClip vidCliper;
}注册到工具栏菜单的示例调用，ScriptableObject保存成.asset文件：只能在Editor下（非运行时），最常用的就是AssetDatabaseAPI，这些通常会配合[MenuItem]写在静态方法里。
Csharp
public class ScriptableObjectTool
{
[MenuItem("ScriptableObject/CreateMyData")]
public static void CreateMyData() // MenuItem必须加到静态方法上
{
//书写创建数据资源文件的代码 <T>中一定要继承ScriptableObject
MyData myDataAsset = ScriptableObject.CreateInstance<MyData>();
AssetDatabase.CreateAsset(myDataAsset, "Assets/Resources/MyDataTest.asset");//通过编辑器API 根据数据scrpitableobj创建一个数据资源文件
AssetDatabase.SaveAssets();//保存创建的资源
AssetDatabase.Refresh();//刷新界面
}
}在MonoBehaviour中声明对应的ScriptableObject变量，Inspector中用拖数据资源文件关联上去。
这东西也支持使用Rsources和AB包加载。文件被多个对象加载是共享状态的大部分对象都是线程不安全的，而且在线程中不能访问Monobehaviour和ScriptableObjcet对象
Csharp
public class SoTest : MonoBehaviour
{
public MyData myData; // 可以在Inspector关联
void Start()
{
myData = Resources.Load<MyData>("jackData"); // 使用Resource加载
myData.PrintInfo();
}
}场景比如怪物数值模板，可以在里面写一些类型什么的，然后在创建的时候在怪物的Awake中把ScriptableObjcet对象上的数值复制到普通类中
和MonoBehaviour类似，它也有生命周期函数数量较少一般不常用。
[ ⚠️Warning ]
这东西在Editor中的行为是持久化的，但是打包出去就不会持久化了。
这东西其实不是设计来持久化游戏数据的，非要做可以结合其他的IO文件格式做
非持久化数据:
上面是创建了一个资源文件去关联，本地已经有一个持久化的文件了，所以更改会被应用。在runtime使用ScriptableObject.CreateInstance<MyData>()创建的文件是在运行中动态创建的，特点：
UnityEngine.ObjectOnEnable()中初始化Csharp
// 声明一个抽象类AudioPlayBase，继承自ScriptableObject类
public abstract class AudioPlayBase : ScriptableObject
{
public abstract void Play(AudioSource source);
}
[CreateAssetMenu()]
public class RandomPlayAudio : AudioPlayBase
{
public List<AudioClip> clips;
public override void Play(AudioSource source)
{
if (clips.Count == 0) return;
int randomIndex = Random.Range(0, clips.Count); // 随机播放其中一个
AudioClip randomClip = clips[randomIndex];
source.clip = randomClip;
source.Play();
}
}
[CreateAssetMenu()]
public class PlayerAudio : AudioPlayBase
{
public AudioClip clip;
public override void Play(AudioSource source) // 播放单个
{
source.clip = clip;
source.Play();
}
}
public class SoTest : MonoBehaviour
{
public AudioPlayBase audioPlay; // 这个就可以挂载不同类型的PlayAudio实现多态
private void Start()
{
audioPlay.Play(this.GetComponent<AudioSource>());
}
}#todo ScriptableObject保存和加载 最下面有全局的Converter可用
深入理解ScriptableObject-不只是数据容器_哔哩哔哩_bilibili
其实就是一种文件格式，没什么新奇的，我用pandas不是天天干这个吗。.xlsx 本质上是一个压缩包所以需要Zip功能去解压，一般是在Editor模式下去读写Excel进行操作，所以依赖dll很多时候也会放到Editor下。
使用这两个库SharpZipLib；ExcelDataReader（较新版本的需要把ExcelDataReader.DataSet.dll ExcelDataReader.DataSet一块安装）
[ ❌Failure ] 啊我草ExcleDataReader怎么这么坏啊😭
这俩库自己放DLLExcelDataReader.DataSet.dll死活读不出来，但是使用NugetForUnity就没问题，里面不知道做了什么不为人知的邪恶py交易，除非单文件DLLL以后尽量能少自己凑。
（unity2022.3 dll3.7.0）
Csharp
void Start()
{
string excelPath = Application.streamingAssetsPath + "/PlayerInfo.xlsx";
FileStream fileStream = File.Open(excelPath, FileMode.Open, FileAccess.Read);
// xlsx 用 CreateOpenXmlReader，xls 用 CreateBinaryReader
IExcelDataReader reader = ExcelReaderFactory.CreateOpenXmlReader(fileStream);
DataSet dataSet = reader.AsDataSet(); // 转成 DataSet，里面包含所有表
for (int i = 0; i < dataSet.Tables.Count; i++)
{
Debug.Log("表名：" + dataSet.Tables[i].TableName); // 表名
Debug.Log("行数：" + dataSet.Tables[i].Rows.Count); // 行数
Debug.Log("列数：" + dataSet.Tables[i].Columns.Count); // 列数
foreach (DataRow row in dataSet.Tables[i].Rows) // 遍历行
{
foreach (var cell in row.ItemArray) // 遍历列
print(cell.ToString());
}
}
fileStream.Dispose();
}牢唐的工具类思路就是，按照既定格式读取Excel，字符串拼接生成类型CS文件；按照顺序写入二进制到bin文件；读取二进制获得类和字段名，利用反射复赋值存到单例的字典中去。
关注Resolution and Presentation
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。