测试Unity中常用代码的运行所用时间：三维向量和变换位移篇 #性能测试 #Vector3 #tranform.position

最新推荐文章于 2022-11-22 16:53:45 发布
最新推荐文章于 2022-11-22 16:53:45 发布
阅读量638 收藏 2
点赞数 1
分类专栏： 性能分析 文章标签： c# unity unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51720545/article/details/119705632
版权

C# Vector3 和 transform.position 篇

〇、前言

系统自带计时器 -System.Diagnostics.StopWatch- 的使用

System.Diagnostics.StopWatch 的基本使用方法

//引用命名空间
using System.Diagnostics;

//创建一个计时器
Stopwatch timer = new Stopwatch();

//计时开始
timer.Start();

//计时结束
timer.Stop();

//转换成秒形式
decimal second = timer.Elapsed.Ticks * 0.000_000_1m;

//如果要转换成微秒形式:
decimal microSecond =  timer.Elapsed.Ticks * 0.1m;

//在输出面板输出代码所用时间, ":F4"是保留4位小数的意思
Debug.Log($"Takes {second:F4} second");

一、三维向量测试

1. 三维向量的函数方法和属性

首先说说 Vector3 的所有函数方法和属性，如下：

  • 重要属性：
----属性名称----
--------------------------属性作用------------------------
Vector3.right返回 new Vector3(1,0,0); ( static )
Vector3.left返回 new Vector3(-1,0,0); ( static )
Vector3.up返回 new Vector3(0,1,0); ( static )
Vector3.down返回 new Vector3(0,-1,0); ( static )
Vector3.forward返回 new Vector3(0,0,1); ( static )
Vector3.back返回 new Vector3(0,0,-1); ( static )
Vector3.one返回 new Vector3(1,1,1); ( static )
Vector3.zero返回 new Vector3(0,0,0); ( static )
.normalized返回该向量的单位向量：
  e ⃗ = n ⃗ ∣ n ⃗ ∣ \ \vec{e} = \frac {\vec{n}} {\vert \vec{n}\vert}  e =∣n ∣n ​
.magnitude返回该向量的模：
m a g → = ∣ n ⃗ ∣ \overrightarrow{mag}= \vert \vec{n}\vert mag ​=∣n ∣
.sqrMagnitude返回该向量的平方模：
  s q r M a g = n ⃗ ⋅ n ⃗ = ∣ n ⃗ ∣ 2 \ sqrMag = \def\nor{\vec{n}} \nor \cdot \nor = \vert \nor\vert^2  sqrMag=n ⋅n =∣n ∣2;
  • 常用静态方法：
----属性名称----
返回值类型
-------------------------返回值-----------------------
Angle(Vector3 a, Vector3 b)float返回两个向量的夹角(度数)：
  < a ⃗ , b ⃗ > = arccos ⁡ ( a ⃗ ⋅ b ⃗ ∣ a ⃗ ∣ ⋅ ∣ b ⃗ ∣ ) \ \def\fromVec{\mathsf {\vec a}} \def\toVec{\mathsf {\vec b}} <\vec a,\vec b>= \arccos\left( \frac {\fromVec \cdot \toVec} {\vert\fromVec\vert \cdot \vert \toVec\vert} \right)  <a ,b >=arccos(∣a ∣⋅∣b ∣a ⋅b ​)
ClampMagnitude(Vector3 a, float maxLength)Vector3返回方向与 a 相同，长度最大为 maxLength 的向量：
v e c → = min ⁡ { a ⃗ . m a g n i t u d e , m a x L e n g t h } ⋅ a ⃗ . n o r m a l i z e \overrightarrow{vec}= \min\{\vec \mathsf a.magnitude,\mathsf {maxLength}\}\cdot \vec \mathsf a.normalize vec =min{a .magnitude,maxLength}⋅a .normalize
Cross(Vector3 a, Vector3 b)Vector3返回两个向量的叉积：
  v e c → = a ⃗ × b ⃗ = ∣ i ⃗ j ⃗ k ⃗ a ⃗ . x a ⃗ . y a ⃗ . z b ⃗ . x b ⃗ . y b ⃗ . z ∣ \ \def\A{\vec\mathsf a} \def\B{\vec\mathsf b} \overrightarrow{vec} = \A \times \B = \begin{vmatrix} \vec i & \vec j & \vec k \\ \A .x & \A.y & \A.z \\ \B.x & \B.y & \B.z\end{vmatrix}  vec =a ×b =∣∣∣∣∣∣​i a .xb .x​j ​a .yb .y​k a .zb .z​∣∣∣∣∣∣​
Dot(Vector3 a, Vector3 b)float返回两个向量的点积：
  r e s u l t = a ⃗ ⋅ b ⃗ = a ⃗ . x ∗ b ⃗ . x + a ⃗ . y ∗ b ⃗ . y + a ⃗ . z ∗ b ⃗ . z \ \def\A{\vec\mathsf a} \def\B{\vec\mathsf b} result= \A \cdot \B = \A.x*\B.x+\A.y*\B.y+\A.z*\B.z  result=a ⋅b =a .x∗b .x+a .y∗b .y+a .z∗b .z
Scale(Vector3 a, Vector3 b)Vector3返回两个向量各部分对应相乘的结果：
v e c → = n e w   V e c t o r 3 ( a ⃗ . x ∗ b ⃗ . x , a ⃗ . y ∗ b ⃗ . y , a ⃗ . z ∗ b ⃗ . z ) ; \def\A{\vec\mathsf a}\def\B{\vec\mathsf b} \overrightarrow\mathsf {vec} = \mathsf {new \ Vector3}( \A.x*\B.x, \A.y*\B.y, \A.z*\B.z); vec =new Vector3(a .x∗b .x,a .y∗b .y,a .z∗b .z);
Distance(Vector3 a, Vector3 b)float返回a到b的距离：
  d i s = ∣ b ⃗ − a ⃗ ∣ \ dis = \vert \vec\mathsf b - \vec\mathsf a\vert  dis=∣b −a ∣
Lerp(Vector3 a, Vector3 b, float t)Vector3返回a到b的插值( 其中t 会被限制在0~1之间 )：
v e c → = a ⃗ + ( b ⃗ − a ⃗ ) ∗ t \overrightarrow{vec}= \vec\mathsf a + (\vec\mathsf b - \vec\mathsf a)*\mathsf t vec =a +(b −a )∗t
LerpUnclamp(Vector3 a, Vector3 b, float t)Vector3返回a到b的插值( t 不会被限制在0~1之间 )：
v e c → = a ⃗ + ( b ⃗ − a ⃗ ) ∗ t \overrightarrow{vec}= \vec\mathsf a + (\vec\mathsf b - \vec\mathsf a)*\mathsf t vec =a +(b −a )∗t
Magnitude(Vector3 vector)float返回 vector 的模：
  m a g = ∣ v e c t o r → ∣ \ mag = \vert\overrightarrow\mathsf {vector} \vert  mag=∣vector ∣
Normalize(Vector3 vector)Vector3返回 vector 的单位向量：
  e ⃗ = v e c t o r → ∣ v e c t o r → ∣ \ \vec e = \frac {\overrightarrow\mathsf {vector}} {\vert\overrightarrow\mathsf {vector} \vert}  e =∣vector ∣vector ​
SqrMagnitude(Vector3 vector)float返回 vector 的平方模：
s q r M a g = v e c t o r → ⋅ v e c t o r → \def\Vec{\overrightarrow\mathsf {vector}} sqrMag = \Vec \cdot \Vec sqrMag=vector ⋅vector ;
Max(Vector3 a, Vector3 b)Vector3返回由两个向量最大值部分组成的向量：
  v e c → = n e w   V e c t o r 3 ( max ⁡ { a ⃗ . x , b ⃗ . x } , max ⁡ { a ⃗ . y , b ⃗ . y } , max ⁡ { a ⃗ . z , b ⃗ . z } ) ; \ \def\A{\vec\mathsf a} \def\B{\vec\mathsf b} \overrightarrow{vec}= \mathsf {new \ Vector3}(\max\{\A.x,\B.x\},\max\{\A.y,\B.y\},\max\{\A.z,\B.z\});  vec =new Vector3(max{a .x,b .x},max{a .y,b .y},max{a .z,b .z});
Min(Vector3 a, Vector3 b)Vector3返回由两个向量最小值部分组成的向量：
  v e c → = n e w   V e c t o r 3 ( min ⁡ { a ⃗ . x , b ⃗ . x } , min ⁡ { a ⃗ . y , b ⃗ . y } , min ⁡ { a ⃗ . z , b ⃗ . z } ) ; \ \def\A{\vec\mathsf a} \def\B{\vec\mathsf b} \overrightarrow {vec}= \mathsf {new \ Vector3}(\min\{\A.x,\B.x\},\min\{\A.y,\B.y\},\min\{\A.z,\B.z\});  vec =new Vector3(min{a .x,b .x},min{a .y,b .y},min{a .z,b .z});
MoveTowards(Vector3 current, Vector3 target, float maxDistanceDelta)Vector3返回从 current 沿 “ current 指向 target ” 方向移动 maxDistanceDelta 距离后的向量（令 direction = (target - current).Normalized();）：
v e c → = c u r r e n t → + d i r e c t i o n → ∗ m a x D i s t a n c e D e l t a \overrightarrow{vec}= \overrightarrow\mathsf {current}+ \overrightarrow\mathsf {direction}*\mathsf {maxDistanceDelta} vec =current +direction ∗maxDistanceDelta
Project(Vector3 vector, Vector3 onNormal)Vector3返回 vector 在 onNormal 上的投影（令 normal = onNormal.Normalized();）：
v e c → = ( v e c t o r → ⋅ n o r m a l → ) ⋅ n o r m a l → \overrightarrow{vec} = \def\Nor{\overrightarrow\mathsf {normal}} \left(\overrightarrow\mathsf {vector}\cdot\Nor \right)\cdot \Nor vec =(vector ⋅normal )⋅normal
ProjectOnPlane(Vector3 vector, Vector3 planeNormal)Vector3返回 vector 在面上的投影（令 normal = planeNormal.Normalized();）：
v e c → = v e c t o r → − ( v e c t o r → ⋅ n o r m a l → ) ⋅ n o r m a l → \overrightarrow{vec} = \def\Vec{\overrightarrow\mathsf {vector}} \def\Nor{\overrightarrow\mathsf {normal}} \Vec - \left(\Vec \cdot\Nor\right)\cdot \Nor vec =vector −(vector ⋅normal )⋅normal
Reflect(Vector3 inDirection, Vector3 inNormal)Vector3返回 inDirection 在 inNormal 上的反射（令 normal = inNormal.Normalized(); dir = inDirection;）：
v e c → = d i r → − 2 ∗ ( d i r → ⋅ n o r m a l → ) ⋅ n o r m a l → \overrightarrow\mathsf {vec} = \def\Dir{\overrightarrow\mathsf{dir}} \def\Nor{\overrightarrow\mathsf{normal}} \Dir - 2 *\left(\Dir \cdot \Nor\right) \cdot \Nor vec =dir −2∗(dir ⋅normal )⋅normal
SignedAngle(Vector3 from, Vector3 to, Vector3 axis)float返回两个向量在法向量为 axis 的面上的投影之间的夹角：
∠ a n g l e = A n g l e ( P r o j e c t O n P l a n e ( f r o m ⃗ , a x i s ⃗ ) , P r o j e c t O n P l a n e ( t o ⃗ , a x i s ⃗ ) ) ; \angle angle = \mathsf{Angle(ProjectOnPlane(\vec {\bold {from}},\vec {\bold {axis}}),ProjectOnPlane(\vec {\bold {to}},\vec {\bold {axis}}))}; ∠angle=Angle(ProjectOnPlane(from ,axis ),ProjectOnPlane(to ,axis ));
  • 常用方法：
----属性名称----
返回值类型
-------------------------返回值-----------------------
.Scale(Vector3 scale)void该向量为与 scale 各部分对应相乘的结果：
v e c → = n e w   V e c t o r 3 ( x ∗ s a c l e → . x , y ∗ s a c l e → . y , z ∗ s a c l e → . z ) ; \def\B{\overrightarrow\mathsf {sacle}} \overrightarrow\mathsf {vec} = \mathsf{new \ Vector3}( x*\B.x, y*\B.y, z*\B.z); vec =new Vector3(x∗sacle .x,y∗sacle .y,z∗sacle .z);
.Set(float newX, float newY, float newZ)void不开新的内存空间的改变该向量值的方法：
v e c → = n e w   V e c t o r 3 ( n e w X , n e w Y , n e w Z ) ; \overrightarrow\mathsf {vec} = \mathsf{new \ Vector3}(\mathsf{newX}, \mathsf{newY}, \mathsf{newZ}); vec =new Vector3(newX,newY,newZ);
.Normalize()void单位化该向量：
e ⃗ = n ⃗ n ⃗ . m a g n i t u d e \vec e = \frac{\vec n}{\vec n.\mathsf magnitude} e =n .magnituden ​

2. 三维向量测试

介绍完三维向量的基本常用函数方法，接下来将进行一系列测试来说明各方法的最佳使用环境。
接下来所有测试都以以下代码为标准代码块（更详细的见测试代码运行所用时间（一）)，并在测试不同内容时进行不同修改：

...
// ==!==(修改区 0) 修改 count 大小
private int count = 100_000;
...

private void OnClicked()
{
    // ==!==(修改区 1) 最初初始化代码块
    ...

    for (int testIndex = -1; testIndex < (n/*测试实验个数(预热和对比区除外)*/ + 1) * 3; ++testIndex)
    {
    	// ==!==(修改区 2) 每次初始化代码块
    	...
    
    	
		int index = Mathf.FloorToInt(testIndex * 0.334f);
		
        Stopwatch timer = new Stopwatch();
        timer.Start();
        switch (index)//每个测试 3 次
        {
            //传统"预热"
            case -1:
                break;

            // case 0 一般都为普通循环(对比区)
            case 0:
                for (int i = 0; i < count; ++i) { }
                break;

            // ==!==(修改区 3) 其他测试代码块
			case 1:
				...
				break;
				
			...
        }

        timer.Stop();
        UnityEngine.Debug.Log($"{index}: Takes -{timer.Elapsed.Ticks}- ticks");

        // ==!==(修改区 4) 结束后进行其余操作的代码块
        ...
    }
}

(1). 初始化、创建和赋值

//(修改区 2)
Vector3 dir = Vector3.zero;

其中 测试实验个数 n = 4 
//(修改区 3)
case 1:
    for (int i = 0; i < count; ++i)
    {
    	Vector3 tmpDir = Vector3.up;
    }
    break;
case 2:
    for (int i = 0; i < count; ++i)
    {
        dir = Vector3.up;
    }
    break;
case 3:
    for (int i = 0; i < count; ++i)
    {
        dir = new Vector3(0, 1, 0);
    }
case 4:
    for (int i = 0; i < count; ++i)
    {
        dir.Set(0, 1, 0);
    }
    break;

在Unity中多次测试后取稳定值，记录实验数据：

次数\实验编号01234
1608912182455115477
2609912182354885488
3612913182454685511

(2). Distance、magnitude 和 sqrMagnitude

//(修改区 1)
Vector3 targetPos = Random.onUnitSphere * Random.Range(0f, 42f);
Vector3 startPos = Vector3.zero;

//(修改区 2)
float len = 0;

其中 测试实验个数 n = 5 
//(修改区 3)
case 1:
    for (int i = 0; i < count; ++i)
    {
    	len = Vector3.Distance(startPos,targetPos);
    }
    break;
case 2:
    for (int i = 0; i < count; ++i)
    {
        len = targetPos.magnitude;
    }
    break;
case 3:
    for (int i = 0; i < count; ++i)
    {
        len = Vector3.Magnitude(targetPos);
    }
case 4:
    for (int i = 0; i < count; ++i)
    {
        len = targetPos.sqrMagnitude;
    }
    break;
case 5:
    for (int i = 0; i < count; ++i)
    {
        len = Vector3.SqrMagnitude(targetPos);
    }
    break;

在Unity中多次测试后取稳定值，记录实验数据：

次数\实验编号012345
162966122123161176275188677
25556579723677204181360911996
350365150220431576970847656
4752638841201513409117128624
563062636123971627471567714

由上述实验数据可得：

在进行向量之间距离的比较时，最好用 sqrMagnitude；
如果需要用到向量的模就还是用 magnitude；

关于 Distance 和 magnitude 的区别，本博主认为是两个向量差引起的，所以再次进行实验：

//(修改区 1)
Vector3 targetPos = Random.onUnitSphere * Random.Range(0f, 42f);
Vector3 startPos = Vector3.zero;
Vector3 dir = targetPos - startPos;

//(修改区 2)
float len = 0;

其中 测试实验个数 n = 4 
//(修改区 3)
case 1:
    for (int i = 0; i < count; ++i)
    {
    	len = Vector3.Distance(startPos,targetPos);
    }
    break;
case 2:
    for (int i = 0; i < count; ++i)
    {
        len = (targetPos - startPos).magnitude;
    }
    break;
case 3:
    for (int i = 0; i < count; ++i)
    {
        len = Vector3.Magnitude(targetPos - startPos);
    }
case 4:
    for (int i = 0; i < count; ++i)
    {
        len = dir.magnitude;
    }
    break;

再在Unity中进行多次测试后取稳定值，记录实验数据：

次数\实验编号01234
183738458404704624710289
210442966140310443439605
38042868639578446139601

由此可发现：

在 distance 和 magnitude 中：
如果要计算两点之间的距离，用 distance 是最好的选择；
如果要计算一个向量的模，用 magnitude 是最好的选择；

(3). 由 normalize 引出的各个数字运算耗费时间

一般情况下，我们都会认为 单位化向量 的性能消耗比较大，以为其中有 1 n ⃗ ⋅ n ⃗ \frac {1} {\sqrt{\vec n \cdot \vec n}} n ⋅n ​1​，既有除的操作，又有根号的操作。
于是下面先来测试一下各个运算符的性能消耗：

//(修改区 1)
float creator = 1.0001f;
float sqrtNum = 114514.114514f;
double outsideNum = 0;

//(修改区 2)
double num = 1314.520f;

其中 测试实验个数 n = 8 
//(修改区 3)
case 1:
    for (int i = 0; i < count; ++i)
    {
    	num += creator;
    }
    break;
case 2:
    for (int i = 0; i < count; ++i)
    {
        num -= creator;
    }
    break;
case 3:
    for (int i = 0; i < count; ++i)
    {
        num *= creator;
    }
case 4:
    for (int i = 0; i < count; ++i)
    {
        num /= creator;
    }
    break;
case 5:
    for (int i = 0; i < count; ++i)
    {
    	num %= creator;
    }
    break;
case 6:
    for (int i = 0; i < count; ++i)
    {
        num = sqrtNum;
    }
    break;
case 7:
    for (int i = 0; i < count; ++i)
    {
        num = Mathf.Sqrt(sqrtNum);
    }
case 8:
    for (int i = 0; i < count; ++i)
    {
        num = System.Math.Sqrt(sqrtNum);
    }
    break;

//(修改区 4)
outsideNum = num;//为了让 num 有被使用到，防止被优化没了

在Unity中进行多次测试后取稳定值，记录实验数据：

次数\实验编号012345678
18373827377637618161148683175289222418
28793760376137608492147772877295222517
38383950378937608168148903742298612673

本博主为了方便观察，画出直观图：

:05 :10 :15 :20 :25 :30 3760~3873 3759~3903 3873~4258 3760~3958 3760~3778 3782~5465 3758~3829 3760~3848 3759~3773 8160~8166 8158~8697 8151~8341 14766~15025 14774~14949 14856~15055 2744~3577 2868~4044 3369~4163 28363~29649 29500~29701 29555~31073 2409~2420 2511~2526 2520~4093 加 减 乘 除 求余 (double)float Unity Sqrt System Sqrt 数字运算性能测试直观图

但是 System.Math.Sqrt 的超短时间计算确实出乎意料。本博主测试了每次测试 count *= 10，结果发现 System.Math.Sqrt 与 count 成线性相关 还是 1:1 那种。而且每次计算结果和 Unity.Mathf.Sqrt 的计算结果一样。

这次意料之外的测试在以后再进行探究。

接下来测试一下 Normalize 和 Sqrt 的时间消耗：

//(修改区 1)
Vector3 targetPos = Random.onUnitSphere * Random.Range(0f, 42f);
Vector3 norDir;
double outsideNum;

//(修改区 2)
double num = 1314.520f;

其中 测试实验个数 n = 7 
//(修改区 3)
case 1:
    for (int i = 0; i < count; ++i)
    {
    	norDir = dir.normalized;
    }
    break;
case 2:
    for (int i = 0; i < count; ++i)
    {
         dir.Normalize();
         norDir = dir;
    }
    break;
case 3:
    for (int i = 0; i < count; ++i)
    {
        Vector3.Normalize(dir);
        norDir = dir;
    }
case 4:
    for (int i = 0; i < count; ++i)
    {
        outsideNum = Mathf.Sqrt((float)num);
    }
    break;
case 5:
    for (int i = 0; i < count; ++i)
    {
        float sqrMag = dir.sqrMagnitude;
        norDir = dir / Mathf.Sqrt(sqrMag);
    }
    break;
case 6:
    for (int i = 0; i < count; ++i)
    {
        float sqrMag = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z;
        norDir = dir / Mathf.Sqrt(sqrMag);
    }
    break;
case 7:
    for (int i = 0; i < count; ++i)
    {
        float sqrMag = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z;
        norDir = dir / System.Math.Sqrt(sqrMag);
    }
    break;

//(修改区 4)
norDir = Vector3.zero;

在Unity中多次测试后取稳定值，记录实验数据：

次数\实验编号01234567
15041107908933910299136709828137029550343
2602103803846209776632458809546910549984
3486104342845939793634093846986912947001

由实验数据可知 Normalize 的性能与 直接 1/Mathf.Sqrt(.sqrMagnitude) 没有太大的区别。而且使用 1/System.Math.Sqrt(.sqrMagnitude)会比正常1/Mathf.Sqrt(.sqrMagnitude)快一些，速度比大概是10:7；
还比 Normalize 快一倍多。

二、变换系统测试

1. transform 的结构

transform 中的所有属性如下：
transform中的所有属性
transform 中的所有方法如下：transform中的所有方法

2. transform.position 赋值和获取

//(修改区 1)
Vector3 startPos = transform.position;

//(修改区 2)
Vector3 assignPos;

其中 测试实验个数 n = 4 
//(修改区 3)
//获取 transform.position
case 1:
    for (int i = 0; i < count; ++i)
    {
    	assignPos = transform.position;
    }
    break;
//正常 transform.position 加赋值
case 2:
    for (int i = 0; i < count; ++i)
    {
        transform.position += Vector3.up;
    }
    break;
//正常 transform.position 赋值
case 3:
    for (int i = 0; i < count; ++i)
    {
        transform.position = Vector3.up;
    }
    break;
//用向量赋值和 tranform.position 赋值比较
case 4:
    for (int i = 0; i < count; ++i)
    {
        assignPos = Vector3.up;
    }
    break;

//(修改区 4)
transform.position = startPos;

再在Unity中进行多次测试后取稳定值，记录实验数据：

次数\实验名称对比组获取加赋值赋值向量赋值
12881182921924741175651949
23811587372673441588882264
35151715822852831535512276

由实验记录可知，单单获取 transform.position 的时间消耗和赋值 transform.position 差不多，甚至还是给普通向量赋值的 70 倍。
可以得出结论：

如果要使一个物体移动，先计算好所有向量的合向量，再给 transform.position 赋值，也不能频繁获取 transform.position ，如果常用的话就先储存在 Vector3 中。

新人博主，请大家多多光照~~如果有什么不正确或不足的地方请在评论区积极指出哟，一起学习一起进步~

汁橙c
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图形开发之3D向量类(C#)
学而时习之
04-29 3396
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace VectorDemo { /// /// 3D向量类 /// public class Vector3 { public float X { ge
Unity性能基准测试
01-27
本文来自于个人博客，详细介绍了如何收集性能指标、通过这些指标创建基准并可视化查看性能指标的变化。我们将讲解如何使用多个Unity工具，通过简单的方法收集性能指标并创建基准，这些工具包括：1.UnityTestRunner2.UnityPerformanceTestingExtension3.UnityPerformanceBenchmarkReporter作为Unity的开发人员，通常会遇到以下情形：项目不久前还运行得流畅而快速，但进行一次或多次改动后，场景运行速度明显变慢，帧数也降了很多，其它性能问题开始不断出现。寻找造成性能下降的改动会非常困难。如果你是一名得Unit
Unity Profiler 找出耗性能的代码
若风
10-20 3449
unity的profile很方便但有时会出现找不到耗时操作的脚本的情况，如： 在代码中加入如下代码段，可以定位到耗时的代码 UnityEngine.Profiling.Profiler.BeginSample("225 SetDataContext"); // 耗时代码 ....balabala UnityEngine.Profiling.Profiler.EndSample(); 注意：B...
unity中测试函数运行时间工具
08-11
测试函数运行时间的工具
C++ vs Python向量运算速度评测
weixin_33797791的博客
12-05 550
本文的起源来自最近一个让我非常不爽的事。 我最近在改一个开源RNN工具包currennt（http://sourceforge.net/projects/currennt/），想用它实现RNNLM功能。 currennt使用了大量的面向对象的编程技巧，可以使用GPU，向量运算使用了thrust库（https://code.google.com/p/thrust/）。 RNNLM（http:/...
Scripts_.las.ffC#unity_C#las点云c_C#las点云_黑科技kb_unity点云_
09-28
点云技术是现代计算机视觉和三维重建领域中的一个重要概念，它通过收集来自物体表面的大量三维坐标点来形成对现实世界的数字表示。在Unity引擎中，处理点云数据可以为游戏开发、虚拟现实应用和仿真等领域带来逼真的...
MapToolBox，unity插件，用于绘制VectorMap的版本0.1.3 经测试在2022.3.17版本中可以正常使用
最新发布
03-08
如有报错，可以配合 ...使用
SimpleJSON：方便的Unity软件包格式的AC＃json读写器
02-04
使用UnityPackageManager（适用于Unity 2019.3或更高版本） 打开包管理器窗口（菜单：窗口>包管理器） 选择“从git URL添加软件包...”，在弹出窗口中添加以下链接： 使用UnityPackageManager（适用于Unity 2019.1...
Unity-Runtime-Animation-Recorder：在Unity运行时中记录动画。 可以保存为.anim，maya或FBX ASCII格式
02-06
Unity-Runtime-Animation-Recorder 该项目可以使您使用Unity在运行时中录制动画，并可以保存为.anim或Maya .ma格式。 尽管Maya拥有自己的物理模拟器，但是统一性要快得多，并且可以通过脚本轻松控制细节移动。安装...
Unity.IO.Compression：Unity的System.IO.Compression端口
02-06
Unity.IO.Compression 这是微软的代码端口从。... 这似乎是使GZipStream和DeflateStream类在Unity中工作的最干净，最稳定的方法。 在找到Unity Asset Store上的插件。 由，请与我们联系以获取问题。
C#封装的三维向量
05-31
C#封装的三维向量，代码封装性还是比较不错的
前端性能优化-CSS的性能优化：--transform与position的区别、硬件加速工作原理及注意事项
thewar196的博客
05-06 3191
前端性能优化 CSS的性能优化： transform与position的区别 硬件加速工作原理及注意事项
unity游戏开发中常用api（旋转，输入，时间，移动，数学，力，射线，计算距离，实例化，协程，颜色，异步加载，）
MagicianThirteen
07-11 297
（一）旋转类 transform.localEulerAngles=new Vector3(x,y,z); 角度是相对角度，相对于父物体的x/y/z轴旋转，而不是根据自己的x/y/z轴来旋转。 仅使用该变量读取角度和将角度设置为绝对值。不要增大角度，因为当角度超过 360 度时，会失效 ...
Unity3d 三维空间，向量，矩阵
互动教程网[www.hdjc8.com]
02-21 6126
Vector3:  Unity3D中Vector3类定义（只写有用的）：  属性：  x，y，z                表示一个空间向量。  this                       用于访问x，y，z三个数据使用数组的方式访问，比如[0][1][2]  normalized            返回单位化向量后的值（只读）。单位化向量是个很重要
2018腾讯移动游戏实践经验——Unity的C#性能
NRatel的博客
11-02 812
相关文章目录 零、客户端性能评审内容： 条目 详细 1、内存消耗 针对不同档次客户端配置，实际占用的物理内存消耗合理； 2、客户端帧率 在默认画质配置下，核心游戏从场景FPS无明显波动，稳定再一定数值以上； 3、CPU占用 不同游戏场景下，CPU占用合理； 4、流量消耗 对于分局的游戏场景，以单局消耗流量作为判断标准；对于不分局游戏场景 或 流量与局时有关的场景，以一定...
unity api中文手册_unity 中文API之Vector3
weixin_39524574的博客
11-27 548
Vector3 三维向量Description 描述Representation of 3D vectors and points.表示3D的向量和点。This structure is used throughout Unity to pass 3D positions and directions around. It also contains functions for doing com...
unity-2D游戏地面检测 三射线检测
weixin_56041433的博客
11-22 2190
unity-2D游戏地面检测，三射线检测！
C#测试代码的运行时间
手在键盘敲很轻
06-15 174
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch(); watch.Start(); //开始监视代码运行时间 //需要测试的代码 watch.Stop(); //停止监视 TimeSpan timespan = watch.Elapsed; //获取当前实例测量得出的总时间...
Unity二维平面上物体的移动（十一）-位移和推动力移动的区别
weixin_43196587的博客
11-04 612
如何解决这一问题呢？我们在判断生成小鸟的条件时，不能按照原来的思路进行刚体速度的判断，需要根据位移情况进行判断。或者如果按照刚体速度判断，则必须给小鸟使用推动力走抛物线，不能按照位移来实现。以上程序中小鸟移动是靠位移来实现的，但是由于之前生成小鸟的脚本是按预制体的刚体速度判断的，而小鸟之前的发射是靠推动力实现的，所以会出现小鸟在位移情况下不具备刚体速度，小鸟不断产生的情况。//重力初始速度为0。
在unity C#中如何使用stopwatch测试代码运行时间，应该放在什么方法下面
05-10
在Unity C#中使用Stopwatch测试代码运行时间，可以按照以下步骤： 1. 引入命名空间：在代码文件的顶部添加`using System.Diagnostics;`来引入Stopwatch类所在的命名空间。 2. 创建Stopwatch对象：在需要测试的代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值