2017-11-30 09:40:52 qq_37601496 阅读数 305
  • Unity3D入门到精通-(2)Profiler工具精讲

    本次系列课程的目标是让Unity3D初学者掌握Unity3d的性能优化技术,根据Profiler工具监控的CPU,GPU,内存等数据(CPU执行时间,GPU执行时间,内存大小等),分析程序的性能瓶颈,从而提高程序性能。 适合对象:Unity初学开发者,Unity中级开发者,所有对游戏开发有兴趣的人员。 学习条件:有一定的Unity3D基础,了解C#的基本开发知识。

    2705 人正在学习 去看看 张刚

一:什么是性能优化?
常见的优化类型包括:性能优化(重点),流程优化,体验优化。
性能优化的目标:(1)游戏流畅运行,(多种帧数标准,避免卡顿)
常见的帧数标准:60帧(终极目标),30帧(移动端要求),24帧。
(2)游戏符合市场需要。(硬件的兼容性 ,安装包的大小。)

二:优化常见的误区:
误区一:我的游戏很简单,不需要优化。
正解简单:玩法简单,架构简单。与优化无关哦!
误区二:优化工作尽早进行。
正解:由于项目是团队开发的,优化过早的话造成代码改动的地方会有很多地方呢!过早优化还会浪费时间和精力,而且意义不大。
误区三:性能优化=Degbug
正解:它们直接毫无关系。
三:游戏优化的两大原则:
(1)不过早做优化。
(2)用户不察觉原则。
a.玩家不一定能发现欠优化的地方。
b.玩家不一定能发现优化后欠佳的地方。

四:优化的组成部分:
脚本,
图形与物理,
文件。

脚本:1.常见的性能黑点(不够好的地方)。
2.如何找到需要优化的代码。
图形与物理:
1.美术资源
2.物理效果
文件:
1.安装包的优化
2.资源包的优化
3.工作流程的优化
所有游戏都要优化吗?
三个事实:
1.性能完美是我们追求的目标。
2.不同类型的游戏对优化的侧重点不一样。
3.优化工作占生命周期非常大的一部分

五: Profile(分析器)与时间
这里写图片描述
Profiler:用来评估性能的工具。
这里写图片描述

运行之后的工作状态哦!
这里写图片描述
CPU资源使用情况。
这里写图片描述
显卡资源的使用情况。
这里写图片描述
内存资源。
这里写图片描述
音频资源。
这里写图片描述
视频资源。
这里写图片描述
物理碰撞资源。
这里写图片描述
网络通信情况。
六:使用profiler

七:常规循环与变量调用

这里写图片描述

void FixedUpdate()
    {

    }

    void Update()
    {

    }

    void LateUpdate()
    {

}

变量的隐性调用。

这三个是常规的循环:优化工作中看看是否常规循环中是否有不不要的东西。
八:场景搜索与协程
GameObject.Find()方法的使用。
当频繁的使用一个物体是,可以将其存储起来,方便多次使用哦!
九:合理降低数学精度
1.计算距离 Vector3.magnitude 长度 返回向量的长度(只读)使用但是使用sqrMagnitude(计算平方很快)来更优化呢!
这里写图片描述
举例说明:

这里写图片描述
点积>0表示向量同向。

float distance1 = (player1.position - transform.position).magnitude;
        float distance2 = (player2.position - transform.position).magnitude;
        print(distance1);
        print(distance2);
        print(distance1 < distance2);
        float distance11 = (player1.position - transform.position).sqrMagnitude;
        float distance22 = (player2.position - transform.position).sqrMagnitude;
        print(distance11);
        print(distance22);
        print(distance11 < distance22);
    float angle = Vector3.Angle(player2.forward, player1.forward);
    float dot = Vector3.Dot(player2.forward, player1.forward);
    print(dot);
    print(angle);

十:对象池 优化技术(以后会更新的,下次讲啦!)

2017-05-10 16:32:48 xxlyyr 阅读数 225
  • Unity3D入门到精通-(2)Profiler工具精讲

    本次系列课程的目标是让Unity3D初学者掌握Unity3d的性能优化技术,根据Profiler工具监控的CPU,GPU,内存等数据(CPU执行时间,GPU执行时间,内存大小等),分析程序的性能瓶颈,从而提高程序性能。 适合对象:Unity初学开发者,Unity中级开发者,所有对游戏开发有兴趣的人员。 学习条件:有一定的Unity3D基础,了解C#的基本开发知识。

    2705 人正在学习 去看看 张刚

一、CPU优化

unity性能开销主要有两个大的方面:unity引擎相关的消耗和代码的消耗,其中引擎开销可以细分为渲染,动画,物理,UI,粒子等。

(1) 减少draw call。(合并mesh,batching等)

(2) 优化资源,控制资源的渲染量。(控制mesh的vertex和triangle,LOD,Occlusion Culing等)

(3) 针对使用NGUI,将动态ui和静态ui分离开来,放在不同的UIPanel里面,因为ui的重绘最小单位是UIPanel,一个UIPanel里面动态改变的ui不宜太多,最好控制5-10之间,还要推荐使用UGUI进行ui的开发工作。

(4) 尽量进行资源的预加载操作,缓解在实例化时的压力。

(5)可以适当开启Mipmap,可以减少渲染通道的带宽,提升渲染的效率。


二、内存优化

unity内存的占用主要包括:资源内存、托管堆动态内存以及引擎占用内存。

(1)纹理优化,最大size不能超过1024x1024(RGBA32 4MB),Android上可以采用ETC Compress,iOS采用PVRTC。

(2)对于ui纹理,关闭Mipmap功能,如果开启的话内存会提升1.33倍。

(3)如果不是特殊功能需要,纹理关闭read/write功能,如果开启将会使纹理的内存扩大一倍。

(4)防止资源加载以后常驻在内存,原则上尽量利用磁盘空间来换取内存空间。

(5)不要去动态修改material的内容,如果需要修改material来达到目的,使用替换material的方式。

2013-10-29 19:14:02 u012465377 阅读数 845
  • Unity3D入门到精通-(2)Profiler工具精讲

    本次系列课程的目标是让Unity3D初学者掌握Unity3d的性能优化技术,根据Profiler工具监控的CPU,GPU,内存等数据(CPU执行时间,GPU执行时间,内存大小等),分析程序的性能瓶颈,从而提高程序性能。 适合对象:Unity初学开发者,Unity中级开发者,所有对游戏开发有兴趣的人员。 学习条件:有一定的Unity3D基础,了解C#的基本开发知识。

    2705 人正在学习 去看看 张刚

                                                                           unity3d 常规性能优化技巧

以下技巧并不是必须的,但是对于想要提升游戏性能的人来说应该还是很不错的。

  优化的常规技巧

  n 剖析你的游戏。 不要花费时间来优化那些晦涩的代码或者缩减图形文件的大小,除非这是你游戏的瓶颈。第一次剖析你的游戏将会使你发现你游戏的瓶颈。Apple's Shark是一个很好的用来剖析基于OpenGL的程序的工具。

  n 再次剖析你的游戏。 优化之后不要忘记再剖析一次你的游戏,这样可以检查你所做的优化是否达到了预期的效果。当然,这样做也可能会使你发现更多的瓶颈。

  n 流程第一、性能第二。 花费时间来使你游戏的创建尽可能地流畅。尽可能快地修正游戏中的错误将会使你后期更容易优化你的游戏。

  n 在Scene View中测试场景。 这样做将会使你清楚了解这个场景中的物体或者附加在物体上的脚本是否降低了游戏性能。如果Scene View反应迟钝,那么有可能是图形方面的原因,如果Scene View反应不迟钝,那么瓶颈可能出在脚本或者物理系统上。

  n 禁用指定游戏物体。 在play模式下,尝试禁用并启用游戏物体来排查出游戏慢的原因。

  网格

  n 如果可能的话,把相邻的物体(网格)合并为一个只有一个材质的物体(网格)。 比如,你的游戏中包含一个桌子,上面有一堆东西,你完全可以在3d程序中将它们合并在一起(这可能也需要你将这些物体的纹理合并为一个大的纹理集)。减少需要渲染的物体的数量可以极大地提高游戏性能。

  n 不要有不必要的网格。 如果你的游戏场景中有一个人物,那么他应该是一个网格。如果你有一个船,那么它也应该只是一个网格。

  n 每一个网格只用一种材质。

  n 使用极少的面数的网格(比如500个多边形以下)。

  n 最好把你人物的三角面数量控制在1500-2000个之间。 这个数量可以说是游戏质量和性能之间一个均衡值。如果你的模型有四边形,那么在导入模型的时候,引擎将会把每个四边形变为两个三角形。

  光照

  n 像素光。 像素光可以让你的游戏看起来效果很牛逼,但是不要使用过多的像素光。在你的游戏中可以使用质量管理器来调节像素光的数量来取得一个性能和质量的均衡点。

  n 性能占用顺序:聚光灯>点光源>平行光。 一个好的点亮场景的方法就是先得到你想要的效果,然后看看哪些光更重要;在保持光效的前提下看看哪些光可以去掉。

  n 点光源和聚光灯只影响它们范围内的网格。 如果一个网格处于点光源或者聚光灯的照射范围之外,并且光源的attenuate开关是打开的,那么这个网格将不会被光源所影响,这样就可以节省性能开销。这样做理论上来讲可以使用很多小的点光源而且依然能有一个好的性能,因为这些光源只影响一小部分物体。一个网格在有8个以上光源影响的时候,只响应前8个最亮的光源。

  贴图

  n 在外观不变的前提下,贴图大小越小越好。 如果你的显卡的显存不够大的话,你游戏中的贴图将会被转存到系统内存中,在显卡调用它们的时候再传到显卡中。对于比较新的电脑来说,内存和显卡之间有足够的带宽来达到一个很好的性能;如果你很无耻地用了巨多的大图片的话,在低显存的电脑上运行你的游戏的时候,你的游戏必然会挂掉。倒是没有必要在图形编辑软件中调整贴图的大小。你可以在unity导入贴图的时候进行调整。

  n 不要使用低质量的图片。 在小播放界面的游戏中使用低质量的jpeg图片或者低色彩的png图片亦或是gif图片没什么问题。在发布游戏的时候,引擎会自动压缩这些图片,多重压缩和解压将会降低图片的质量,所以最好保持贴图文件的分辨率为原始分辨率。这样就会减少多重压缩和解压所导致的图片失真现象。

  本部分设定了隐藏,您已回复过了,以下是隐藏的内容

  音频

  n 使用.ogg格式的压缩音频文件。 所有其他的音频格式文件在发布时将会被转储为未压缩音频文件。

  n 对于小音效使用未压缩音频文件。 Unity在运行过程中会解压所有的ogg文件。它会把经常播放的音效转储为WAV或者aiff格式的文件,这样就可以不用cpu总是解压这些文件了。比如快速的枪声,脚步声和其他一些连续播放又很短小的音效。

  物理

  n 每一个刚体都需要大量运算,所以刚体越少越好。 当角速度和移动速度降低到某个临界值的时候,刚体将会进入休眠状态。当刚体进入休眠状态时,他们需要的运算量将会大量减少,但是会保留很少的一部分运算来随时应对外部的作用力或者物体的碰撞。

  n 多重碰撞相比一个接一个地碰撞将会花费更多的运算。 比如一个球去碰一堆球所需要的计算量会远远大于去一个一个地碰这些球所需要的计算量。

  Shaders

  n 多重效果的shader就比看起来样式很单一的shader要更耗费资源。 同样在一个拥有贴图和光反射的物体上,使用VertexLit Diffuse shader无疑是最省资源的。

  本部分设定了隐藏,您已回复过了,以下是隐藏的内容

  脚本

  n 选择适当的算法。 选择一个正确的算法将会更容易进行优化。最好的算法不一定就是算法复杂度最低的算法。

  n 尽量不要使用FixedUpdate()函数。 这种函数在每一个物体的每一个脚本中每秒调用50-100次。如果可以的话尽量把这个函数里面的东西放在Update()函数中执行。

  n 如果可能的话,在脚本无用的时候禁用它。 比如有一个敌人在数千米开外的位置,完全可以禁用它的AI脚本,直到需要的时候再启用这个脚本。启用和禁用物体的最好方法就是使用gameObject.SetActiveRecursively(false)函数,并且把物体的球碰撞和盒碰撞都置为trigger。

  n 如果不需要Update函数的时候就删掉它。 在创建一个新脚本的时候,系统会自动加入一个空的Update函数,如果你不使用它的话就把它删掉。

  n 适当的时候使用物体引用。 如果调用一个物体需要走一个很弯的逻辑,比如someGameObject.transform.gameObject.rigidbody.transform.gameObject.rigidbody.transform,这样就不如直接在脚本中声明一个变量,把要调用的物体直接赋给这个变量。

  n 尽量使用协同函数。 协同函数开销很小,相比于一直在进行不必要调用的Update函数来说更好用。举例来说,如果你有一个控制灯光渐明渐暗的脚本,你就完全可以使用协同函数来替代Update函数。这样的话,在大多数时间灯光不变化的时候,系统的开销会很小。如果这一过程是在Update函数中执行的话,Update函数会一直检测是否需要执行渐变。

  n 尽量不要使用搜索物体的函数。 比如GameObject.FindByTag()和 GameObject.GetComponent(),搜索组件的函数也一样尽量少用。搜索就等于遍历,搜索一次物体就要把所有物体都遍历一遍,这个开销我不说大家也应该都明白。尤其要注意,不要在Update()和FixedUpdate()中使用搜索函数,如果需要的话,最好在Start函数中使用变量来获取一次,之后调用就直接用这个变量。

  n 尽量不要使用SendMessage()函数或者类似的函数。 SendMessage()函数的执行速度至少比直接调用一个function慢100倍,随着脚本和函数的增多,这个速度会更慢,所以如果能直接调用函数的话就直接调用。

  n 关于JavaScript(Boo)中的动态类型。 在使用JavaScript时,声明变量的尽量明确指定它的类型。

本文转自http://www.unitymanual.com/forum.php?mod=viewthread&tid=5683&highlight=优化

2014-09-03 19:02:02 ynnmnm 阅读数 9155
  • Unity3D入门到精通-(2)Profiler工具精讲

    本次系列课程的目标是让Unity3D初学者掌握Unity3d的性能优化技术,根据Profiler工具监控的CPU,GPU,内存等数据(CPU执行时间,GPU执行时间,内存大小等),分析程序的性能瓶颈,从而提高程序性能。 适合对象:Unity初学开发者,Unity中级开发者,所有对游戏开发有兴趣的人员。 学习条件:有一定的Unity3D基础,了解C#的基本开发知识。

    2705 人正在学习 去看看 张刚

    Unity官方文档中有一篇是讲图形性能优化的,这篇文章无疑是指导Unity开发图形优化的最佳文章。Unity圣典曾翻译过旧版,但是太老了,跟最新文档差别很大。我试着翻译一下最新文档,点击查看E文链接

Optimizing Graphics Performance  图形性能优化

Good performance is critical to the success of many games. Below are some simple guidelines for maximizing the speed of your game’s graphical rendering.

良好的性能是很多游戏成功的关键。以下是一些最大化提高游戏图形渲染速度的简单指导。

Where are the graphics costs  图形开销在哪里

The graphical parts of your game can primarily cost on two systems of the computer: the GPU or the CPU. The first rule of any optimization is to find where the performance problem is; because strategies for optimizing for GPU vs. CPU are quite different (and can even be opposite - it’s quite common to make GPU do more work while optimizing for CPU, and vice versa).

游戏的图形显示部分主要消耗计算器的两个系统:GPU和CPU。任何优化的第一规则都是查明性能瓶颈在哪里,因为优化GPU和优化CPU的策略常常是不同的(甚至常常是相互对立的——常常为了优化CPU而把它的一些工作交给GPU,反之亦然)。

Typical bottlenecks and ways to check for them:

典型的瓶颈和检查方法:

  • • GPU is often limited by fillrate or memory bandwidth.
  • • GPU常常受限于填充率和存储器带宽。
    • • Does running the game at lower display resolution make it faster? If so, you’re most likely limited by fillrate on the GPU.
    • • 如果游戏在较低的显示分辨率上运行更快,则很可能是受限于GPU的填充率。
  • • CPU is often limited by the number of things that need to be rendered, also known as “draw calls”.
  • • CPU常常受限于需要渲染的物品数量,我们通常叫它“draw calls”(绘制调用,一般用专业术语“draw call”)
    • • Check “draw calls” in Rendering Statistics window; if it’s more than several thousand (for PCs) or several hundred (for mobile), then you might want to optimize the object count.
    • • 在Rendering Statistics窗口查看“draw calls”,如果在PC上它常常多达几千个,或者在移动设备上多达几百个,那么你可能需要优化物体的数量。

Of course, these are only the rules of thumb; the bottleneck could as well be somewhere else. Less typical bottlenecks:

当然,这只是根据经验的主要开销点,而瓶颈也可能在别处。不那么典型的瓶颈有:

  • • Rendering is not a problem, neither on the GPU nor the CPU! For example, your scripts or physics might be the actual problem. Use Profiler to figure this out.
  • • GPU和CPU在渲染方面都没有问题!比如,你的脚本或者物理可能是真正的问题所在,使用Unity的Profiler查明问题。
  • • GPU has too many vertices to process. How many vertices are “ok” depends on the GPU and the complexity of vertex shaders. Typical figures are “not more than 100 thousand” on mobile, and “not more than several million” on PC.
  • • GPU处理太多的顶点。到底多少个顶点是ok的,依赖于具体的GPU设备和顶点着色器的复杂度。典型的数字是,在移动设备上“不要超过10万个”,在PC上“不要超过数百万个”。
  • • CPU has too many vertices to process, for things that do vertex processing on the CPU. This could be skinned meshes, cloth simulation, particles etc.
  • • CPU处理太多的顶点 —— 针对CPU处理顶点的情况。这可能是蒙皮网格、衣服模拟、粒子等。

CPU optimization - draw call count  CPU优化:draw call数量

In order to render any object on the screen, the CPU has some work to do - things like figuring out which lights affect that object, setting up the shader & shader parameters, sending drawing commands to the graphics driver, which then prepares the commands to be sent off to the graphics card. All this “per object” CPU cost is not very cheap, so if you have lots of visible objects, it can add up.

为了渲染一个物体到屏幕上,CPU需要做一些工作——比如,哪些灯光影响物体,建立着色器和着色器参数,给显卡驱动发送绘制命令,然后准备发送给显卡的命令。单个物体的CPU开销并不昂贵,但是如果有很多可见物体,这些开销会累加。

So for example, if you have a thousand triangles, it will be much, much cheaper if they are all in one mesh, instead of having a thousand individual meshes one triangle each. The cost of both scenarios on the GPU will be very similar, but the work done by the CPU to render a thousand objects (instead of one) will be significant.

所以,举例来说,比如你有1000个三角形,相比每个三角形一个独立的网格,它们都在一个网格中对CPU开销要低得多。这两种方案对于GPU来说差别不大,但是CPU渲染1000个物体(代替1个)的开销多很多。

In order to make CPU do less work, it’s good to reduce the visible object count:

为了让CPU做更少的工作,减少可见对象的数量是很有效的:

  • • Combine close objects together, either manually or using Unity’s draw call batching.
  • • 合并接近的物体。可以手工合并,也可以利用Unity的draw call batching(批量draw call)。
  • • Use less materials in your objects, by putting separate textures into a larger texture atlas and so on.
  • • 在物体中使用更少的材质。可以把独立的纹理合并成一个更大的纹理图集。
  • • Use less things that cause objects to be rendered multiple times (reflections, shadows, per-pixel lights etc., see below).
  • • 避免使用导致物体被渲染多次的效果(比如反射、阴影、像素光照等,见下面)。

Combine objects together so that each mesh has at least several hundred triangles and uses only one Material for the entire mesh. It is important to understand that combining two objects which don’t share a material does not give you any performance increase at all. The most common reason for having multiple materials is that two meshes don’t share the same textures, so to optimize CPU performance, you should ensure that any objects you combine share the same textures.

合并物体使每个网格有至少几百个三角形,并且整个网格只使用一种材质。合并两个不共用同一材质的物体并不会提升性能,理解这一点很重要。拥有多个材质的最常见原因是两个网格不共用相同的纹理,所以为了优化CPU性能,你要确保合并的物体共用相同的纹理。

However, when using many pixel lights in the Forward rendering path, there are situations where combining objects may not make sense, as explained below.

然而,如果在正向渲染路径下使用很多像素光照,有一些情况下合并物体并没有效果,下面解释。

GPU: Optimizing Model Geometry  GPU:优化模型几何

When optimizing the geometry of a model, there are two basic rules:

有两个优化模型几何的基本原则:

  • • Don’t use any more triangles than necessary
  • • 不用使用任何非必要的多余三角形
  • • Try to keep the number of UV mapping seams and hard edges (doubled-up vertices) as low as possible
  • • 尽可能减少UV贴图接缝和硬边(顶点增多了一倍)的数量。

Note that the actual number of vertices that graphics hardware has to process is usually not the same as the number reported by a 3D application. Modeling applications usually display the geometric vertex count, i.e. the number of distinct corner points that make up a model. For a graphics card, however, some geometric vertices will need to be split into two or more logical vertices for rendering purposes. A vertex must be split if it has multiple normals, UV coordinates or vertex colors. Consequently, the vertex count in Unity is invariably higher than the count given by the 3D application.

注意,图形硬件处理的顶点实际数量常常跟3D应用程序报告的不一致。建模应用常常显示几何顶点数量,即构成模型的不同角点的数量。然而,图形显卡为了渲染目的可能会把一些几何顶点拆分成两个或者更多个逻辑顶点。如果一个顶点有多个法线、UV坐标或者顶点颜色,那么必须把它拆分。因此,Unity中的顶点数量一定会比3D应用程序给的定点数多。

While the amount of geometry in the models is mostly relevant for the GPU, some features in Unity also process models on the CPU, for example mesh skinning.

模型的几何数量主要对GPU有意义,Unity中的一些特性也在CPU上处理模型,比如网格蒙皮。

Lighting Performance  光照性能

Lighting which is not computed at all is always the fastest! Use Lightmapping to “bake” static lighting just once, instead of computing it each frame. The process of generating a lightmapped environment takes only a little longer than just placing a light in the scene in Unity, but:

不需要计算的光照是最快的。使用光照贴图烘焙静态光,只需要一次,代替了每帧计算。生成光照贴图环境,比在Unity的场景中放一个光源消耗的时间仅仅多一点,但是

  • • It is going to run a lot faster (2–3 times for 2 per-pixel lights)
  • • 它的运行速度要快很多(对于2个逐像素光照,快2-3倍)
  • • And it will look a lot better since you can bake global illumination and the lightmapper can smooth the results
  • • 并且,因为可以烘焙全局光照,并且lightmapper(光照贴图工具)可以让烘焙的结果更平滑,所以它看起来效果也好很多

In a lot of cases there can be simple tricks possible in shaders and content, instead of adding more lights all over the place. For example, instead of adding a light that shines straight into the camera to get “rim lighting” effect, consider adding a dedicated “rim lighting” computation into your shaders directly.

许多情况下,有一些着色器和内容的简单技巧,而不是在所有地方添加更多的光源。比如,为了获得“边缘光照”效果,可以直接在着色器中添加一次“边缘光照”计算,而不是添加一个直射相机的灯。

Lights in forward rendering 正向渲染中的光照

Per-pixel dynamic lighting will add significant rendering overhead to every affected pixel and can lead to objects being rendered in multiple passes. On less powerful devices, like mobile or low-end PC GPUs, avoid having more than one Pixel Light illuminating any single object, and use lightmaps to light static objects instead of having their lighting calculated every frame. Per-vertex dynamic lighting can add significant cost to vertex transformations. Try to avoid situations where multiple lights illuminate any given object.

对每一个受到影响的像素,逐像素动态光会累加可观的渲染耗费,并且会导致物体在多个通道被渲染。在性能比较差的设备上,比如移动设备或者低端PC的GPU,避免使用多于一个的像素灯照射任何单个物体,并且使用光照贴图来照亮静态物体而不是每帧计算光照。逐顶点动态光照会在顶点转换上累加客观的消耗。努力避免多个灯光照射任何给定物体的情况。

If you use pixel lighting then each mesh has to be rendered as many times as there are pixel lights illuminating it. If you combine two meshes that are very far apart, it will increase the effective size of the combined object. All pixel lights that illuminate any part of this combined object will be taken into account during rendering, so the number of rendering passes that need to be made could be increased. Generally, the number of passes that must be made to render the combined object is the sum of the number of passes for each of the separate objects, and so nothing is gained by combining. For this reason, you should not combine meshes that are far enough apart to be affected by different sets of pixel lights.

如果你使用像素光照,对于每一个网格,像素光照射它多少次,它将被渲染多少次。如果你合并两个相距较远的网格,将会增大合并物体的有效大小。渲染的时候,照射到合并物体任一部位的所有的像素光都会被计算,所以,需要渲染通道数量会增加。一般地,渲染合并物体的通道数量等于分别渲染独立物体的通道数量之和,所以,合并没有作用。因此,你不应该合并足够远以至于受不同像素光影响的网格。

During rendering, Unity finds all lights surrounding a mesh and calculates which of those lights affect it most. The Quality Settings are used to modify how many of the lights end up as pixel lights and how many as vertex lights. Each light calculates its importance based on how far away it is from the mesh and how intense its illumination is. Furthermore, some lights are more important than others purely from the game context. For this reason, every light has a Render Mode setting which can be set to Important or Not Important; lights marked as Not Important will typically have a lower rendering overhead.

渲染的时候,Unity查找所有网格周围所有的光,并计算哪一个对网格影响最大。Quality  Settings(质量设置)可以修改最终多少个光是像素光,多少个是顶点光。每一个光基于距离网格的距离计算它的权重和光照强度。此外,取决于游戏内容,有些光比别的光更重要。因此,每个光源有渲染模式设置,可以把它设置为重要或者不重要,标记为不重要的光一般有更低的渲染开销。

As an example, consider a driving game where the player’s car is driving in the dark with headlights switched on. The headlights are likely to be the most visually significant light sources in the game, so their Render Mode would probably be set to Important. On the other hand, there may be other lights in the game that are less important (other cars’ rear lights, say) and which don’t improve the visual effect much by being pixel lights. The Render Mode for such lights can safely be set to Not Important so as to avoid wasting rendering capacity in places where it will give little benefit.

举例来说,考虑一个赛车游戏,玩家的车开着车头灯,在黑夜中行驶。车头灯是游戏中最重要的可见光,所以它们的渲染模式可能要设置为重要。另一方面,可能游戏里的其它灯光没那么重要(比如其它汽车的尾灯),对这些灯光来说,使用像素光照提升可视效果作用不大,可以把它们设置为不重要,避免在只能获得较少效果的地方浪费渲染性能。

Optimizing per-pixel lighting saves both CPU and the GPU: the CPU has less draw calls to do, and the GPU has less vertices to process and pixels to rasterize for all these additional object renders.

对于CPU和GPU来说,优化逐像素光照都可以减少开销:CPU需要处理的draw call少了,GPU需要处理的顶点和光栅化所有这些额外对象的渲染的像素少了。

GPU: Texture Compression and Mipmaps  GPU:纹理压缩和多重纹理

Using Compressed Textures will decrease the size of your textures (resulting in faster load times and smaller memory footprint) and can also dramatically increase rendering performance. Compressed textures use only a fraction of the memory bandwidth needed for uncompressed 32bit RGBA textures.

使用压缩纹理会减少纹理大小(结果是更快的加载速度和更小的内存占用)并且大幅提高渲染性能。压缩纹理占用的存储带宽只有未压缩的32位RGBA纹理的一小部分。

Use Texture Mip Maps  使用多重纹理

As a rule of thumb, always have Generate Mip Maps enabled for textures used in a 3D scene. In the same way Texture Compression can help limit the amount of texture data transfered when the GPU is rendering, a mip mapped texture will enable the GPU to use a lower-resolution texture for smaller triangles.

作为经验,在3D场景中使用的纹理总是启用生成多重纹理。以同样的方式,GPU渲染时,纹理压缩可以帮助限制传输的纹理数据量,因为对于较小的三角形,多重纹理允许GPU使用较低分辨率的纹理。

The only exception to this rule is when a texel (texture pixel) is known to map 1:1 to the rendered screen pixel, as with UI elements or in a 2D game.

这条规则的例外是,知道texel(纹理像素)是1:1映射到渲染的屏幕像素,比如UI元素或者在2D游戏中。

LOD and Per-Layer Cull Distances  LOD(多细节层次)和每层剔除距离

In some games, it may be appropriate to cull small objects more aggressively than large ones, in order to reduce both the CPU and GPU load. For example, small rocks and debris could be made invisible at long distances while large buildings would still be visible.

在一些游戏中,为了减少CPU和GPU负担,可以适当剔除小物体。比如,远距离的小石头和碎片可以设为不可见,而大的建筑物是可见的。

This can be either achieved by Level Of Detail system, or by setting manual per-layer culling distances on the camera. You could put small objects into a separate layer and setup per-layer cull distances using the Camera.layerCullDistances script function.

可以使用LOD系统,或者在相机上设置手工每层剔除距离,来做剔除。你可以把小物体放入一个独立的层,然后使用Camera.layerCullDistance脚本函数设置每层的剔除距离。

Realtime Shadows  实时阴影

Realtime shadows are nice, but they can cost quite a lot of performance, both in terms of extra draw calls for the CPU, and extra processing on the GPU. For further details, see the Shadows page.

实时阴影效果很好,但是会消耗很多的性能,包括CPU额外的draw call和GPU额外的处理。更多细节,看文档的阴影页面

GPU: Tips for writing high-performance shaders  GPU:写高性能着色器的提示

A high-end PC GPU and a low-end mobile GPU can be literally hundreds of times performance difference apart. Same is true even on a single platform. On a PC, a fast GPU is dozens of times faster than a slow integrated GPU; and on mobile platforms you can see just as large difference in GPUs.

毫不夸张的说,高端PC和低端移动设备的GPU性能可能相差几百倍,甚至在同一个平台上也相差这么大。在PC上,一个快的GPU几十倍速于低端集成GPU;在移动设备上,也是如此。

So keep in mind that GPU performance on mobile platforms and low-end PCs will be much lower than on your development machines. Typically, shaders will need to be hand optimized to reduce calculations and texture reads in order to get good performance. For example, some built-in Unity shaders have their “mobile” equivalents that are much faster (but have some limitations or approximations - that’s what makes them faster).

所以,请记住,在移动设备和低端PC上的GPU性能,可能比你的开发机器低得多。典型地,为了良好的性能,着色器需要手工优化来减少计算和纹理读取。例如,一些内置的Unity着色器有快得多的等价的“移动”版本(但是有些限制或者是近似值 - 就是这些使得更快)。

Below are some guidelines that are most important for mobile and low-end PC graphics cards:

下面是一些针对移动设备或者低端PC显卡的指南:

Complex mathematical operations  复杂的数学运算

Transcendental mathematical functions (such as powexplogcossintan, etc) are quite expensive, so a good rule of thumb is to have no more than one such operation per pixel. Consider using lookup textures as an alternative where applicable.

复杂的数学函数(比如pow、exp、log、cos、sin、tan等)开销很大,所以一个好的经验是不要在每个像素上使用这些函数。如果可以,考虑使用查找纹理作为替换。

It is not advisable to attempt to write your own normalizedotinversesqrt operations, however. If you use the built-in ones then the driver will generate much better code for you.

不建议自己实现normalize、dot、inversesqrt等运算,使用内置的函数,驱动会生成更好的代码。

Keep in mind that alpha test (discard) operation will make your fragments slower.

记住,alpha测试(裁剪)操作会使你的片段更慢。

Floating point operations  浮点运算

You should always specify the precision of floating point variables when writing custom shaders. It is critical to pick the smallest possible floating point format in order to get the best performance. Precision of operations is completely ignored on many desktop GPUs, but is critical for performance on many mobile GPUs.

写自定义的着色器时,应该指定浮点数精度。为了获得更好的性能,选用最小的可行浮点数格式是很关键的。运算精度在很多台式机GPU上完全被忽略,但是在移动设备GPU上,它对于性能很关键。

If the shader is written in Cg/HLSL then precision is specified as follows:

如果着色器是Cg/HLSL写的,精度如下:

  • • float - full 32-bit floating point format, suitable for vertex transformations but has the slowest performance.
  • • float - 32位浮点数格式,适合用于顶点变换,但是性能最慢。
  • • half - reduced 16-bit floating point format, suitable for texture UV coordinates and roughly twice as fast as float.
  • • half - 减半的16位浮点数格式,适合用于纹理UV坐标,性能大约是float的2倍。
  • • fixed - 10-bit fixed point format, suitable for colors, lighting calculation and other high-performance operations and roughly four times faster than float.
  • • fixed - 10位顶点格式,适合用于颜色、光照计算和其它高性能操作,比float大约快4倍。

If the shader is written in GLSL ES then the floating point precision is specified specified as highpmediumplowp respectively.

如果着色器用GLSL ES写的,浮点数格式分别是:highpmediumplowp

For further details about shader performance, please read the Shader Performance page.

了解着色器性能的更多细节,请阅读文档着色器性能页面

Simple Checklist to make Your Game Faster  让你的游戏更快的简要清单

  • • Keep vertex count below 200K..3M per frame when targetting PCs, depending on the target GPU
  •  如果目标设备是PC,保持顶点数低于20万-300万,依赖于目标GPU。
  • • If you’re using built-in shaders, pick ones from Mobile or Unlit category. They work on non-mobile platforms as well; but are simplified and approximated versions of the more complex shaders.
  •  如果你使用内置着色器,选用Mobile或Unlit种类的。它们也可以在非移动平台良好工作,是复杂着色器的简化或者近似值版本。
  • • Keep the number of different materials per scene low - share as many materials between different objects as possible.
  •  保持每次场景不同材质的数量 —— 不同物体尽可能共享材质。
  • • Set Static property on a non-moving objects to allow internal optimizations like static batching.
  •  对于不移动的物体,设置Static属性,允许像静态批处理这样的内部优化。
  • • Do not use Pixel Lights when it is not necessary - choose to have only a single (preferably directional) pixel light affecting your geometry.
  •  除非必要,不要使用像素光 —— 只选用一个(尽可能平行光)像素光影响你的几何体。
  • • Do not use dynamic lights when it is not necessary - choose to bake lighting instead.
  •  除非必要,不要使用动态光 —— 选择烘焙光照来代替。
  • • Use compressed texture formats when possible, otherwise prefer 16bit textures over 32bit.
  •  如果可以,尽量使用压缩纹理格式;否则,16位格式纹理性能好于32位的。
  • • Do not use fog when it is not necessary.
  •  除非必要,不要使用雾效果。
  • • Learn benefits of Occlusion Culling and use it to reduce amount of visible geometry and draw-calls in case of complex static scenes with lots of occlusion. Plan your levels to benefit from occlusion culling.
  •  学习遮挡剔除的好处,然后使用它来降低可见几何体和有许多遮挡的复杂静态场景draw call的数量。设计你准备从遮挡剔除获得好处的等级。
  • • Use skyboxes to “fake” distant geometry.
  •  使用天空盒“冒充”远距离的几何体。
  • • Use pixel shaders or texture combiners to mix several textures instead of a multi-pass approach.
  •  使用像素着色器或纹理合并来混合几个纹理,而不是多通道逼近。
  • • If writing custom shaders, always use smallest possible floating point format:
  •  如果写自定义着色器,使用尽可能小的浮点数格式:
    • • fixed / lowp - for colors, lighting information and normals,
    •  fixed / lowp - 用于颜色、光照信息和法线,
    • • half / mediump - for texture UV coordinates,
    •  half / mediump - 用于纹理UV坐标,
    • • float / highp - avoid in pixel shaders, fine to use in vertex shader for position calculations.
    •  float / highp - 避免在像素着色器中使用,用于顶点着色器的位置计算比较好。
  • • Minimize use of complex mathematical operations such as powsincos etc. in pixel shaders.
  •  在像素着色器中,尽可能少用复杂的数学函数,比如powsincos等。
  • • Choose to use less textures per fragment.
  •  每个片段使用较少的纹理。
更详细的细节请参考以下各优化主题:
另外,我的这篇Blog《Unity优化总结》记录了我对我们一款游戏的优化方案,是比较实用的具体优化方法。
转载请注明出处:http://blog.csdn.net/ynnmnm/article/details/39003147,作者:夜风
2016-08-30 10:35:14 qq_24643673 阅读数 218
  • Unity3D入门到精通-(2)Profiler工具精讲

    本次系列课程的目标是让Unity3D初学者掌握Unity3d的性能优化技术,根据Profiler工具监控的CPU,GPU,内存等数据(CPU执行时间,GPU执行时间,内存大小等),分析程序的性能瓶颈,从而提高程序性能。 适合对象:Unity初学开发者,Unity中级开发者,所有对游戏开发有兴趣的人员。 学习条件:有一定的Unity3D基础,了解C#的基本开发知识。

    2705 人正在学习 去看看 张刚

原文链接:http://blog.csdn.net/yesy10/article/details/7861236

1、顶点性能

      一般来说,如果您想在iPhone 3GS或更新的设备上每帧渲染不超过40,000可见点,那么对于一些配备 MBX GPU的旧设备(比如,原始的 iPhone,如 iPhone 3g和 iPod Touch第1和第2代)来说,你应该保证每帧的渲染顶点在10000以下。

2、光照性能

      像素的动态光照将对每个受影响的像素增加显著的计算开销,并可能导致物体会被渲染多次。为了避免这种情况的发生,您应该避免对于任何单个物体都使用多个像素光照,并尽可能地使用方向光。需要注意的是像素光源是一个渲染模式(Render Mode)设置为重要(Important)的光源。像素的动态光照将对顶点变换增加显著的开销。所以,应该尽量避免任何给定的物体被多个光源同时照亮的情况。对于静态物体,采用烘焙光照方法则是更为有效的方法。

3、角色

      每个角色尽量使用一个Skinned Mesh Renderer,这是因为当角色仅有一个 Skinned Mesh Renderer 时, Unity 会 使用可见性裁剪和包围体更新的方法来优化角色的运动,而这种优化只有在角色仅含有一个 Skinned Mesh Renderer 时才会启动。角色的面数一般不要超过1500,骨骼数量少于30就好,角色Material数量一般1~2个为最佳。

4、静态物体

      对于静态物体定点数要求少于500,UV的取值范围不要超过(0,1)区间,这对于纹理的拼合优化很有帮助。不要在静态物体上附加Animation组件,虽然加了对结果没什么影响,但是会增加CPU开销。

 5、摄像机

      将远平面设置成合适的距离,远平面过大会将一些不必要的物体加入渲染,降低效率。另外我们可以根据不同的物体来设置摄像机的远裁剪平面。Unity 提供了可以根据不同的 layer 来设置不同的 view distance ,所以我们可以实现将物体进行分层,大物体层设置的可视距离大些,而小物体层可以设置地小些,另外,一些开销比较大的实体(如粒子系统)可以设置得更小些等等。

6、DrawCall

      尽可能地减少 Drawcall 的数量。 IOS 设备上建议不超过 100 。减少的方法主要有如下几种: Frustum Culling ,Occlusion Culling , Texture Packing 。 Frustum Culling 是 Unity 内建的,我们需要做的就是寻求一个合适的远裁剪平面;Occlusion Culling ,遮挡剔除, Unity 内嵌了 Umbra ,一个非常好 OC 库。但 Occlusion Culling 也并不是放之四海而皆准的,有时候进行 OC 反而比不进行还要慢,建议在 OC 之前先确定自己的场景是否适合利用 OC 来优化; Texture Packing,或者叫 Texture Atlasing ,是将同种 shader 的纹理进行拼合,根据 Unity 的 static batching 的特性来减少 draw call 。建议使用,但也有弊端,那就是一定要将场景中距离相近的实体纹理进行拼合,否则,拼合后很可能会增加每帧渲染所需的纹理大小,加大内存带宽的负担。这也就是为什么会出现“ DrawCall 降了,渲染速度也变慢了”的原因。

Unity3d之性能优化

阅读数 775

没有更多推荐了,返回首页