Lizq的个人博客

发表于 本文字数： 1.3k 阅读时长 ≈ 5 分钟

参数传递

Out参数

只用于输出结果

  • 调用前不需要初始化
  • 方法内部必须赋值
  • 引用传递

In参数

阅读全文 »

发表于 更新于 本文字数： 4.6k 阅读时长 ≈ 17 分钟

粗筛阶段（Broad Phase）

SAP（扫描线算法）

不论碰撞体本身是圆形、OBB、多边形，都可以获得顶点集合的minPoint: (minX, minZ)和maxPoint: (maxX, maxZ)，得到最大外接矩形也就是AABB，将所有待检测对象的AABB投影到对应的轴上。每个对象在每个轴上都会得到一个线段，两个不同对象的线段如果在某一个轴上没有交集，就证明一定不存在碰撞，反之，在所有轴上都存在交集，则这两个对象的AABB一定发生了碰撞，如果对象本身就是AABB那就检测完毕，否则需要进一步判断两个对象是否实际碰撞。

算法

先从X轴开始，遍历每个对象，投影可以产生两个端点minValue, maxValue，将所有对象的投影端点都放入一个数组内，并按坐标从小到大进行排序。维护两个列表：活跃列表[]和重叠对列表[]。扫描线从左到右扫描这些端点。

阅读全文 »

发表于 更新于 本文字数： 1.4k 阅读时长 ≈ 5 分钟

Span

Span是 C# 7.2 引入的值类型，核心作用是零分配、高性能地表示连续的内存区域，可以直接操作数组、字符串、非托管内存等连续内存块，避免不必要的内存拷贝，大幅减少GC压力。
总的来说：Span就像一个 “内存视图”，不拥有内存，只是对已有内存的安全封装和高效访问。

1.1 核心用法

1.1.1 高性能内存操作，避免数组拷贝

传统方式处理数组子集时会产生拷贝，Span直接操作原内存：

阅读全文 »

发表于 更新于 本文字数： 1.5k 阅读时长 ≈ 6 分钟

1、固定托管对象的地址

.NET的GC在进行可达性遍历后会将所有使用到的内存进行压缩（Compact），空出一整块未使用的内存方便后续申请使用，这时候，原先代码里还在使用的内存就可能会变动位置，指针就会失效。所以fixed在这里的作用就是告诉GC不要compact我这个托管对象，常常配合指针进行较为底层的操作。

1
2
3
4
5
6
7
8
9
10
unsafe
{
    int[] arr = {1, 2, 3};

    fixed (int* p = arr)
    {
        // scope范围内arr会被pin住，GC不会移动它
        Console.WriteLine(p[0]);
    }
}
  • 这种方式会有一定内存损耗，可能会影响GC产生内存碎片。
  • fixed只用用于内建类型数组，别用自己引用类型元素数组，它是不会递归pin的

2、固定大小缓冲区字段fixed buffer

阅读全文 »

发表于 更新于 本文字数： 1.2k 阅读时长 ≈ 4 分钟

视角移动和缩放

假如你的游戏场景是在XZ平面的，而你的相机是俯视角的，你希望玩家可以拖动屏幕来移动视角，双指交互可以缩放视角。针对这个需求，在FGUI里，包含用户输入的组件：SwipeGesture和PinchGesture。拖动相机分成两个阶段：第一阶段，手指按下并拖动，此时要求场景完全跟随手指移动（跟手）；第二阶段，当手指松开后，根据松开前delta阈值，低于阈值则不进行惯性操作，否则需要根据松开前的速度进行惯性制动位移。

正交相机

正交相机的orthographicSize代表相机高度的一半对应的世界距离，将它乘以2再除以屏幕高度，就可以得到单位像素对应的世界距离。FGUI屏幕delta可以转化为unity屏幕像素delta，最终对应世界空间的delta。
通过这种映射关系，移动视角的第一阶段，可以算出世界空间的delta；移动视角的第二阶段，可以算出世界空间的velocity。

透视相机

阅读全文 »

发表于 更新于 本文字数： 800 阅读时长 ≈ 3 分钟

NPC平滑运动

NPC被赋予一组路线比如List，NPC按照路线行进。当遇到转角时，如果直接改变朝向，NPC会显得过于程序化，必然是不可取的。该篇博客尝试了两种方法，分别是“转角圆弧”和“惰性转向”

1 转角圆弧

在转角时，根据预留量（可以设定与速度线性相关）提前脱离路径转弯，转弯的圆弧是两组边的内切圆。此时NPC的转弯角速度可以根据运动速度、预留量，转角的角度，精确求得。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
using System.Collections.Generic;
using UnityEngine;

public class ArcMove : MonoBehaviour
{
    public float TurnTriggerDistance = 5f;  // 预先转向保留距离
    public float MoveSpeed = 20f;           // 匀速朝向前运动

    private float _angularSpeed = 0f;       // 本次转向的转向速度
    private float _remainingTurnTime = 0f;  // 本次转向的转向时间
    private int _currentNodeIndex = 0;

    private List<Vector3> _route = new()
    {
        new Vector3(10,0,-10),
        new Vector3(-10,0,-10),
        new Vector3(10,0, 0),
        new Vector3(10,0,10),
        new Vector3(-10,0,10),
    };

    private void Start() => ResetState();

    void Update()
    {
        // ECS里的控制系统
        var curPos = transform.position;
        if (_remainingTurnTime <= 0 && _currentNodeIndex == _route.Count - 2)
        {
            var curPoint = _route[_currentNodeIndex];
            var arrivePoint = _route[_currentNodeIndex + 1];
            if (Vector3.Dot(arrivePoint - curPoint, arrivePoint - curPos) < 0)
                ResetState();
        }
        if (_remainingTurnTime > 0)
        {
            _remainingTurnTime -= Time.deltaTime;
            if (_remainingTurnTime <= 0) _angularSpeed = 0;
        }
        else
        {
            var haveNextPoint = _currentNodeIndex + 1 < _route.Count;
            var haveNextNextPoint = _currentNodeIndex + 2 < _route.Count;
            var handled = false;
            if (haveNextNextPoint)
            {
                var curPoint = _route[_currentNodeIndex];
                var nextPoint = _route[_currentNodeIndex + 1];
                var nextNextPoint = _route[_currentNodeIndex + 2];
                var inVector = nextPoint - curPoint;
                var outVector = nextNextPoint - nextPoint;
                var clampTurnTriggerDistance = Mathf.Min(TurnTriggerDistance, Mathf.Min(inVector.magnitude, outVector.magnitude) / 2);
                var nowRemainDist = (curPos - nextPoint).magnitude;
                if (nowRemainDist <= clampTurnTriggerDistance)
                {
                    ++_currentNodeIndex;
                    handled = true;
                    // 脱离
                    var angle = Vector3.SignedAngle(inVector.normalized, outVector.normalized, Vector3.up);
                    var absoluteAngle = Mathf.Abs(angle);
                    if (absoluteAngle < 1f) return; // 角度太小，Tan会很大，安全起见，直接当直线跑
                    var inCircleRadius = nowRemainDist / Mathf.Tan(absoluteAngle * Mathf.Deg2Rad / 2);
                    var arcLength = 2 * Mathf.PI * inCircleRadius * absoluteAngle / 360;
                    _remainingTurnTime = arcLength / MoveSpeed;
                    _angularSpeed = angle / _remainingTurnTime;
                }
            }
            if (haveNextPoint && !handled)
            {
                var curDir = transform.rotation * Vector3.forward;
                var targetDir = _route[_currentNodeIndex + 1] - curPos;
                var diffAngle = Vector3.SignedAngle(curDir.normalized, targetDir.normalized, Vector3.up);
                _angularSpeed = diffAngle * MoveSpeed; // 朝向收敛与速度正相关
            }
        }

        // ECS里的Movement系统
        transform.rotation *= Quaternion.Euler(0, _angularSpeed * Time.deltaTime, 0);
        transform.position = transform.position + MoveSpeed * Time.deltaTime * transform.forward;
    }

    private void ResetState()
    {
        _currentNodeIndex = 0;
        transform.SetPositionAndRotation(_route[_currentNodeIndex], Quaternion.LookRotation(_route[1] - _route[0]));
    }
}
阅读全文 »

发表于 更新于 本文字数： 1.3k 阅读时长 ≈ 5 分钟

1 优化位枚举

1.1 原生HasFlag问题

  • 原生的HasFlag方法会将枚举装箱为Enum类型，产生性能开销
  • Enum本身是一个引用类型，所有具体的枚举类型比如MyColor都是值类型，并且继承自Enum（特殊的继承规则，就像所有C#对象都继承自object，它也是引用类型）。当调用基类Enum的方法时，自身需要装箱成Enum，参数也需要传递给Enum flag，会进行两次装箱
  • HasFlagFast 用泛型值类型参数替代 Enum 引用类型参数，从根源上避免了装箱。Unsafe.As 只是进一步优化了类型转换的性能，而泛型值类型参数才是避免装箱的关键
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 原生判断函数是Enum的实例方法，Enum本身是抽象类（引用类型）
public bool HasFlag(Enum flag){
    // ...
}

// 替换 HasFlag 方法，避免装箱，仅适用于Int32枚举
public static bool HasFlagFast<T>(this T flags, T value) where T : struct, Enum
{
    if (Enum.GetUnderlyingType(typeof(T)) != typeof(int))
        throw new ArgumentException($"枚举类型 {typeof(T).Name} 的底层类型不是 Int32，无法使用此方法", nameof(T));
    var f = Unsafe.As<T, int>(ref flags);
    var v = Unsafe.As<T, int>(ref value);
    return (f & v) == v;
}

1.2 内部发生了什么

阅读全文 »

发表于 更新于 本文字数： 1.9k 阅读时长 ≈ 7 分钟

问题

新项目，在学习FairyGUI，看到官方Demo里的Window示例有这么一段代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 业务层BasicsMain
private Window _winA; // 实例变量
private Window _winB; // 实例变量
private void PlayWindow()
{
    GComponent obj = _demoObjects["Window"];
    obj.GetChild("n0").onClick.Add(() =>
    {
        if (_winA == null)
            _winA = new Window1();
        _winA.Show();
    });

    obj.GetChild("n1").onClick.Add(() =>
    {
        if (_winB == null)
            _winB = new Window2();
        _winB.Show();
    });
}

// FairyGUI.EventListener.cs
public void Add(EventCallback0 callback)
{
    _bridge.Add(callback);
}

// FairyGUI.EventBridge.cs
EventCallback0 _callback0;
public void Add(EventCallback0 callback)
{
    _callback0 -= callback;
    _callback0 += callback;
}

这个PlayWindow函数是每次点击对应按钮都会调用的，但是里面的注册回调却用的匿名函数，虽然内部会先对委托进行解绑再绑定，但是匿名函数，怎敢断定两次调用传入的是同一个函数的？我立马嗅到一丝内存泄漏的异味，但是实际并没有发生。

验证

阅读全文 »

发表于 更新于 本文字数： 4.2k 阅读时长 ≈ 15 分钟

介绍

红黑树(RBT, Red Black Tree)是一种自平衡的二叉搜索树，有如下定义：

  • 根叶黑：根和叶子节点是黑色的（红黑树里的叶子节点其实是空节点Nil）
  • 不红红：红色节点的两个子节点都必须是黑色。（即不能有两个连续的红色节点）
  • 黑同路：从任一节点到其每个叶子节点的所有简单路径都包含相同数目的黑色节点

在这种定义下确保从根到叶子的最长路径不会超过最短路径的两倍，从而保证了高效的查找、插入和删除操作。相较于AVL树的严格平衡，红黑树只求得一种弱平衡，因此它的插入/删除性能是优于AVL树的，但是查询性能则略逊于AVL树。C++里的set、map底层就是红黑树实现的。

插入

阅读全文 »

发表于 本文字数： 1.4k 阅读时长 ≈ 5 分钟

AVL介绍

平衡二叉树(BST, Balanced Binary Tree又称AVL Tree)是自平衡的二叉搜索树(BST, Binary Search Tree)，二叉搜索树的问题是，如果插入顺序是有序的，会导致树退化为线性结构，查询的复杂度退化为$O(N)$。

定义

首先介绍平衡因子(BF, Balance Factor)：$BF(T) = h_L - h_R$，其中$h_L$和$h_R$分别是$T$左右子树的高度。
由此可以进行AVL树的定义：

  • 空树
  • 任一节点的$|BF(T)|<=1$
阅读全文 »
0%