3D 游戏为何如此高效？

Android Blur Guide 2016 Android 模糊指南2016

使用 Showcase/Benchmark App 及 来源: Github。 分配输入 = Allocation.createFromBitmap (rs，source，Allocation.MipmapControl.MIPMAP _ NONE，Allocation.USAGE _ SCRIPT) ; 分配输出 = Allocation.createType (rs，input.getType ()) ; 还可以查看我目前正在开发的 Blur 框架: 达利。

经过大量的实验，我现在可以安全地给你一些可靠的建议，这些建议将使你在使用 Android 框架时在 Android 中的生活更加轻松。

加载和使用缩放的位图(对于非常模糊的图像)

永远不要使用位图的全尺寸。图像越大，需要的模糊越多，模糊半径也越大，通常，模糊半径越大，算法需要的时间越长。

final BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 8;
Bitmap blurTemplate = BitmapFactory.decodeResource(getResources(), R.drawable.myImage, options);

这将用 inSampleSize8加载位图，因此只有原始图像的1/64。测试什么样的 inSampleSize适合您的需要，但是保持它为2 ^ n (2,4,8，...) ，以避免由于缩放而降低质量。更多信息请参见谷歌文档

另一个非常大的优势是位图加载非常快。在我早期的模糊测试中，我认为在整个模糊过程中最长的时间是图像加载。因此，从磁盘加载1920x1080的图像，我的 Nexus5需要500毫秒，而模糊只需要250毫秒左右。

这将用 inSampleSize8加载位图，因此只有原始图像的1/64。测试什么样的 inSampleSize适合您的需要，但是保持它为2 ^ n (2,4,8，...) ，以避免由于缩放而降低质量。更多信息请参见谷歌文档

另一个非常大的优势是位图加载非常快。在我早期的模糊测试中，我认为在整个模糊过程中最长的时间是图像加载。因此，从磁盘加载1920x1080的图像，我的 Nexus5需要500毫秒，而模糊只需要250毫秒左右。

使用渲染脚本

使用渲染脚本

渲染脚本提供了高斯模糊滤波器 ScriptIntrinsicBlur。它具有良好的视觉质量，只是最快的现实你在 Android 上得到。谷歌声称自己是 “通常比多线程 C 实现快2-3倍，比 Java 实现快10倍以上”。Renderscript 非常复杂(使用最快的处理设备(GPU、 ISP 等)) ，还有 V8支持库，使其兼容到2.2版本。至少在理论上，通过我自己的测试和其他开发人员的报告，似乎不可能盲目地使用渲染脚本，因为硬件/驱动程序碎片似乎会导致一些设备出现问题，即使是更高的 sdk lvl (例如我在4.1 Nexus S 上遇到了麻烦) ，所以要小心，在很多设备上测试。这里有一个简单的例子可以帮助你开始:

//define this only once if blurring multiple times
RenderScript rs = RenderScript.create(context);


(...)
//this will blur the bitmapOriginal with a radius of 8 and save it in bitmapOriginal
final Allocation input = Allocation.createFromBitmap(rs, bitmapOriginal); //use this constructor for best performance, because it uses USAGE_SHARED mode which reuses memory
final Allocation output = Allocation.createTyped(rs, input.getType());
final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
script.setRadius(8f);
script.setInput(input);
script.forEach(output);
output.copyTo(bitmapOriginal);

渲染脚本提供了高斯模糊滤波器 ScriptIntrinsicBlur。它具有良好的视觉质量，是你在安卓系统上实际获得的最快速度。谷歌声称自己是 “通常比多线程 C 实现快2-3倍，比 Java 实现快10倍以上”。Renderscript 非常复杂(使用最快的处理设备(GPU、 ISP 等)) ，还有 V8支持库，使其兼容到2.2版本。至少在理论上，通过我自己的测试和其他开发人员的报告，似乎不可能盲目地使用渲染脚本，因为硬件/驱动程序碎片似乎会导致一些设备出现问题，即使是更高的 sdk lvl (例如我在4.1 Nexus S 上遇到了麻烦) ，所以要小心，在很多设备上测试。这里有一个简单的例子可以帮助你开始:

//define this only once if blurring multiple times
RenderScript rs = RenderScript.create(context);


(...)
//this will blur the bitmapOriginal with a radius of 8 and save it in bitmapOriginal
final Allocation input = Allocation.createFromBitmap(rs, bitmapOriginal); //use this constructor for best performance, because it uses USAGE_SHARED mode which reuses memory
final Allocation output = Allocation.createTyped(rs, input.getType());
final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
script.setRadius(8f);
script.setInput(input);
script.forEach(output);
output.copyTo(bitmapOriginal);

在使用 Google “因为它们包括了最新的改进”特别推荐的 Gradle 支持 v8时，只使用 需要添加2行到您的构建脚本，并在当前构建工具(更新的语法为 android Gradle 插件 v14 + )中使用 android.support.v8.renderscript

android {
...
defaultConfig {
...
renderscriptTargetApi 19
renderscriptSupportModeEnabled true
}
}

在使用 Google “因为它们包括了最新的改进”特别推荐的 Gradle 支持 v8时，只使用 需要添加2行到您的构建脚本，并在当前构建工具(更新的语法为 android Gradle 插件 v14 + )中使用 android.support.v8.renderscript

android {
...
defaultConfig {
...
renderscriptTargetApi 19
renderscriptSupportModeEnabled true
}
}

Nexus 5的简单基准测试——比较渲染脚本和其他不同的 java 和渲染脚本实现:

Nexus 5的简单基准测试——比较渲染脚本和其他不同的 java 和渲染脚本实现:

不同图片大小下每个模糊的平均运行时间

不同图片大小下每个模糊的平均运行时间

每秒百万像素可以被模糊化

每个值是250轮的平均值。RS_GAUSS_FAST是 ScriptIntrinsicBlur(而且几乎总是最快的) ，其他以 RS_开始的实现大多是使用简单内核的卷积实现。算法的细节可以在这里找到.这不是纯粹的模糊，因为一个很好的部分是测量的垃圾收集。这可以在这里看到(ScriptIntrinsicBlur在一个100x100的图像与约500轮)

每个值是250轮的平均值。RS_GAUSS_FAST是 ScriptIntrinsicBlur(而且几乎总是最快的) ，其他以 RS_开始的实现大多是使用简单内核的卷积实现。算法的细节可以在这里找到.这不是纯粹的模糊，因为一个很好的部分是测量的垃圾收集。这可以在这里看到(ScriptIntrinsicBlur在一个100x100的图像与约500轮)

刺钉是气相色谱。

刺钉是气相色谱。

您可以自己检查，基准应用程序是在播放商店: BlurBenchmark

您可以自己检查，基准应用程序是在播放商店: BlurBenchmark

尽可能重用 Bitmap (如果优先级: 性能 > 内存占用)

尽可能重用 Bitmap (如果优先级: 性能 > 内存占用)

如果你需要一个活动模糊或类似的多重模糊，你的内存允许它不加载位图从绘制多次，但保持它“缓存”在一个成员变量。在这种情况下，总是尝试使用相同的变量，以保持垃圾收集到最低限度。

如果你需要一个活动模糊或类似的多重模糊，你的内存允许它不加载位图从绘制多次，但保持它“缓存”在一个成员变量。在这种情况下，总是尝试使用相同的变量，以保持垃圾收集到最低限度。

还可以从文件或绘图中检出新的 加载时选择 inBitmap，这将重用位图内存并节省垃圾回收时间。

还可以从文件或绘图中检出新的 加载时选择 inBitmap，这将重用位图内存并节省垃圾回收时间。

从清晰到模糊

从清晰到模糊

简单而天真的方法就是使用2个 ImageViews，一个模糊，一个渐变。但是，如果你想要一个更复杂的外观，顺利淡出从锐利到模糊，然后检查 Roman Nurik 在他的 Muzei 应用程序中介绍了如何做到这一点。

简单而天真的方法就是使用2个 ImageViews，一个模糊，一个渐变。但是，如果你想要一个更复杂的外观，顺利淡出从锐利到模糊，然后检查 Roman Nurik 在他的 Muzei 应用程序中介绍了如何做到这一点。

基本上，他解释说，他预先模糊了一些框架与不同的模糊范围，并使用它们作为关键帧的动画，看起来真的很顺利。

中央处理器只能做一些简单的事情——比如人工智能和其他游戏逻辑。

我们尝试在不同的答案中实现上面提到的渲染脚本模糊。我们被限制使用 v8渲染脚本版本，这给我们带来了很多麻烦。

因此 d 持续存在。

private final Paint mPaint = new Paint();


public Bitmap blur(final String pathToBitmap) {
final BitmapFactory.Options options = new BitmapFactory.Options();
final Bitmap normalOne = BitmapFactory.decodeFile(pathToBitmap, options);
final Bitmap resultBitmap = Bitmap.createBitmap(options.outWidth, options.outHeight, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(resultBitmap);
mPaint.setAlpha(180);
canvas.drawBitmap(normalOne, 0, 0, mPaint);
int blurRadius = 12;
for (int row = -blurRadius; row < blurRadius; row += 2) {
for (int col = -blurRadius; col < blurRadius; col += 2) {
if (col * col + row * row <= blurRadius * blurRadius) {
mPaint.setAlpha((blurRadius * blurRadius) / ((col * col + row * row) + 1) * 2);
canvas.drawBitmap(normalOne, row, col, mPaint);
}
}
}
normalOne.recycle();
return resultBitmap;
}

• 当我们尝试使用渲染脚本时，三星 S3会随机崩溃
• 其他设备(跨不同 API)随机显示不同的颜色问题

这个解决方案远远不够完美，但是基于这样一个事实，它创建了一个合理的模糊效果，即它在一个几乎不透明的“清晰”版本上绘制了同一个图像的高透明版本。Α 取决于到原点的距离。

你可以根据自己的需要调整一些“神奇的数字”。

我想要分享我们肮脏的 Java 版本，它很慢，应该在一个单独的线程上完成，如果可能的话，在使用之前，因此要持久化。

private final Paint mPaint = new Paint();


public Bitmap blur(final String pathToBitmap) {
final BitmapFactory.Options options = new BitmapFactory.Options();
final Bitmap normalOne = BitmapFactory.decodeFile(pathToBitmap, options);
final Bitmap resultBitmap = Bitmap.createBitmap(options.outWidth, options.outHeight, Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(resultBitmap);
mPaint.setAlpha(180);
canvas.drawBitmap(normalOne, 0, 0, mPaint);
int blurRadius = 12;
for (int row = -blurRadius; row < blurRadius; row += 2) {
for (int col = -blurRadius; col < blurRadius; col += 2) {
if (col * col + row * row <= blurRadius * blurRadius) {
mPaint.setAlpha((blurRadius * blurRadius) / ((col * col + row * row) + 1) * 2);
canvas.drawBitmap(normalOne, row, col, mPaint);
}
}
}
normalOne.recycle();
return resultBitmap;
}

这个解决方案远远不够完美，但是基于这样一个事实，它创建了一个合理的模糊效果，即它在一个几乎不透明的“清晰”版本上绘制了同一个图像的高透明版本。Α 取决于到原点的距离。

在游戏中你可能会看到类似的效果，但是它们通常是以一种妥协的方式来达到最大化帧速率的目的。这些优化扩展到你在游戏中看到的所有东西。问题变成了，“我们怎样才能用最少的处理能力创造出最壮观、最真实的场景?”这使得游戏程序员成为最好的优化者。

此外，从艺术的角度来看，还有许多节省计算能力的技巧。在许多游戏中，尤其是老游戏中，阴影是预先计算好的，并且会被“烘烤”到地图的纹理中。很多时候，艺术家们试图用平面(两个三角形)来表现像树木和特殊效果这样的东西，尽管它们看起来大致相同。游戏中的雾是一种避免渲染远距离物体的简单方法，而且通常情况下，游戏对远、中、近视图的每个物体都有多种分辨率。

这是为所有人谁需要增加半径的 ScriptIntrinsicBlur获得更难的高斯模糊。

班级:

 public class GaussianBlur {
private final int DEFAULT_RADIUS = 25;
private final float DEFAULT_MAX_IMAGE_SIZE = 400;


private Context context;
private int radius;
private float maxImageSize;


public GaussianBlur(Context context) {
this.context = context;
setRadius(DEFAULT_RADIUS);
setMaxImageSize(DEFAULT_MAX_IMAGE_SIZE);
}


public Bitmap render(Bitmap bitmap, boolean scaleDown) {
RenderScript rs = RenderScript.create(context);


if (scaleDown) {
bitmap = scaleDown(bitmap);
}


Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);


Allocation inAlloc = Allocation.createFromBitmap(rs, bitmap, Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_GRAPHICS_TEXTURE);
Allocation outAlloc = Allocation.createFromBitmap(rs, output);


ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, inAlloc.getElement()); // Element.U8_4(rs));
script.setRadius(getRadius());
script.setInput(inAlloc);
script.forEach(outAlloc);
outAlloc.copyTo(output);


rs.destroy();


return output;
}


public Bitmap scaleDown(Bitmap input) {
float ratio = Math.min((float) getMaxImageSize() / input.getWidth(), (float) getMaxImageSize() / input.getHeight());
int width = Math.round((float) ratio * input.getWidth());
int height = Math.round((float) ratio * input.getHeight());


return Bitmap.createScaledBitmap(input, width, height, true);
}


public int getRadius() {
return radius;
}


public void setRadius(int radius) {
this.radius = radius;
}


public float getMaxImageSize() {
return maxImageSize;
}


public void setMaxImageSize(float maxImageSize) {
this.maxImageSize = maxImageSize;
}
}

优化实际的执行是什么使游戏更有效率，但这只是一个线性优化。

• 自定义内存管理。对齐内存，较少碎片。

• 因为它将大量内容放入到您的名称空间中(可能会隐藏以前导入的其他对象，而您不会知道)。

• 因为您不知道究竟导入了什么，也不容易找到从哪个模块导入了某个特定的东西(可读性)。

• 自定义数据结构(即没有 STL，相对最小的模板)。
• 装配到位，主要用于 SIMD。

虽然这里的许多答案提供了很好的 怎么做的迹象，我将回答更简单的问题 为什么

• 阀门的 2005年收入和营业利润分别报价为7000万美元和5500万美元。

也许最好的例子(当然最著名的例子之一)是 Id 软件。他们很早就意识到，在 基恩指挥官时代(远早于3D 时代) ，他们想出了一个聪明的方法来实现 ¹，即使它依赖于现代硬件(在这种情况下是 EGA 显卡!)比竞争对手更有优势这会让你的游戏脱颖而出。这是事实，但他们进一步意识到，他们可以获得技术许可，从而从他人那里获得收入，同时能够开发下一代引擎，从而再次超越竞争对手，而不是必须自己开发新游戏和内容。

也许最好的例子(当然最著名的例子之一)是 Id 软件。他们很早就意识到，在 基恩指挥官时代(远早于3D 时代) ，他们想出了一个聪明的方法来实现 ¹，即使它依赖于现代硬件(在这种情况下是 EGA 显卡!)比竞争对手更有优势这会让你的游戏脱颖而出。这是事实，但他们进一步意识到，他们可以获得技术许可，从而从他人那里获得收入，同时能够开发下一代引擎，从而再次超越竞争对手，而不是必须自己开发新游戏和内容。

这些程序员的能力(加上业务头脑)使他们富有。

这些程序员的能力(加上业务头脑)使他们富有。

也就是说，激励这些人的不一定是金钱。这很可能是同样多的渴望去实现，去完成。他们早期赚的钱只是意味着他们现在有时间专注于自己喜欢的事情。虽然许多人都有 外部利益几乎所有仍然程序，并试图找出方法来做得比上一次迭代更好。

也就是说，激励这些人的不一定是金钱。这很可能是同样多的渴望去实现，去完成。他们早期赚的钱只是意味着他们现在有时间专注于自己喜欢的事情。虽然许多人都有 外部利益几乎所有仍然程序，并试图找出方法来做得比上一次迭代更好。

简而言之，撰写茶壶演示的人可能有以下一个或多个问题:

简而言之，撰写茶壶演示的人可能有以下一个或多个问题:

• 更少的时间
• 更少的时间
• 更少的资源
• 更少的资源
• 更少的奖励激励
• 更少的奖励激励
• 减少内部和外部竞争
• 减少内部和外部竞争
• 较小的目标
• 较小的目标
• 没那么有天赋
• less talent

最后一个可能听起来很严厉，但是很明显有一些人比其他人更好，钟形曲线有时有极端的结束，他们往往被吸引到相应的极端结束什么是做的技能。

最后一个可能听起来很严厉，但是很明显有一些人比其他人更好，钟形曲线有时有极端的结束，他们往往会被吸引到相应的极端结束什么是做的技能。

一个较小的目标实际上可能是主要原因。茶壶演示的目标就是这个，一个演示。但不是程序员 技术³的演示。这将是一个(大)操作系统的一个小方面的演示，在这种情况下 DX 渲染。

一个较小的目标实际上可能是主要原因。茶壶演示的目标就是这个，一个演示。但不是程序员 技术³的演示。这将是一个(大)操作系统的一个小方面的演示，在这种情况下 DX 渲染。

对于那些观看演示的人来说，只要它看起来足够好，它使用的 CPU 比 需要多得多，这并不重要。如果没有受益者，就没有消除浪费的动力。相比之下，一个游戏会喜欢有更好的人工智能，更好的声音，更多的多边形，更多的效果闲置周期。

对于那些观看演示的人来说，只要它看起来足够好，它使用的 CPU 比 需要多得多，这并不重要。如果没有受益者，就没有消除浪费的动力。相比之下，一个游戏会喜欢有更好的人工智能，更好的声音，更多的多边形，更多的效果闲置周期。

---

1. 在这种情况下，在 PC 硬件上平滑滚动
2. 在这种情况下，在 PC 硬件上平滑滚动
3. 比我更可能，所以我们都清楚
4. 比我更可能，所以我们都清楚
5. 严格来说，这也会是一个演示给他/她的经理，但同样的驱动器在这里将是时间和/或视觉质量。

你可以在 wikipedia 上找到它的详细信息以及为什么使用它: http://en.wikipedia.org/wiki/Vsync

在交互式会话中执行 from ... import *是可以的。

据我所知，在 Unreal 系列中，有些约定像封装一样被打破了。代码根据游戏的不同被编译成字节码或者直接编译成机器码。此外，对象渲染和打包的形式下，一个网格和物体，如纹理，照明和阴影是预先计算，而作为一个纯粹的3D 动画需要这一点，这实时。当游戏实际运行时，还有一些优化，比如只渲染对象的可见部分，只有在关闭时才显示纹理细节。最后，视频游戏的设计很可能是为了在给定的时间内充分利用平台(例如: Intelx86 MMX/SSE，DirectX，...)。

根据 巨蟒之禅:

这也导致了一个答案: 一个游戏如何才能是有效的？当编写“伟大的大型游戏”时，需要付出巨大的努力来优化游戏的各个方面(现在通常也包括多核优化)。至于 DX 演示，它的重点不是运行速度快，而是演示概念。

此外，帧率是一些考虑，也许茶壶样本运行在全速(可能1000 fps)和大多数游戏是限制刷新频率的显示器(约60 fps)。

返回，然后比较。

您不会将 **locals()传递给函数，对吗？

import os, sys, foo, sqlalchemy, mystuff
from bar import *

现在，如果酒吧模块有任何的“ os”，“ mystuff”，等..。.属性，它们将覆盖显式导入的属性，并且可能指向非常不同的东西。在 bar 中定义 __all__通常是明智的——这表明将隐式导入什么——但是如果不读取和解析 bar 模块并遵循 它的导入，仍然很难跟踪对象来自哪里。当我获得一个项目的所有权时，我首先修复的是 import *网络。

因为 Python 缺少一个“ include”语句，所以 还有的 self参数是显式的，还有的作用域规则非常简单，通常很容易指向一个变量并告诉它这个对象来自哪里——不需要读取其他模块，也不需要任何类型的 IDE (不管怎样，IDE 在自省方面是有限的，因为语言是非常动态的)。

import *打破了这一切。

不要误解我: 如果 import *不见了，我会哭着要它的。但必须谨慎使用。一个好的用例是在另一个模块上提供 facade 接口。

此外，它还有隐藏 bug 的具体可能性。

import os, sys, foo, sqlalchemy, mystuff
from bar import *

现在，如果酒吧模块有任何的“ os”，“ mystuff”，等..。.属性，它们将覆盖显式导入的属性，并且可能指向非常不同的东西。在 bar 中定义 __all__通常是明智的——这表明将隐式导入什么——但是如果不读取和解析 bar 模块并遵循 它的导入，仍然很难跟踪对象来自哪里。当我获得一个项目的所有权时，我首先修复的是 import *网络。

不要误解我: 如果 import *不见了，我会哭着要它的。但必须谨慎使用。一个好的用例是在另一个模块上提供 facade 接口。

我认为在中大型项目中，或者有几个贡献者的小型项目中，在静态分析方面需要最低限度的卫生条件——至少运行 pyflakes，或者更好的是运行一个正确配置的 pylint ——以便在发生错误之前捕捉到几种类型的 bug。

我认为在中大型项目中，或者有几个贡献者的小型项目中，在静态分析方面需要最低限度的卫生条件——至少运行 pyflakes，或者更好的是运行一个正确配置的 pylint ——以便在发生错误之前捕捉到几种类型的 bug。

当然，因为这是 python ——可以随意打破规则并进行探索——但是要小心那些可能增长十倍的项目，如果源代码缺乏规则，那将是一个问题。

这是 非常糟糕的做法，原因有二:

我认为这里缺少一个重要的答案部分。大多数答案告诉你“了解你的数据”。事实上，你必须以同样的方式，以同样的重要程度，了解你的:

• 代码可读性
• CPU (时钟和缓存)
• 重写变量/函数等的风险

对于 第一点: 我们来看一个例子:

from module1 import *
from module2 import *
from module3 import *


a = b + c - d

在这里，当看到代码没有人会得到想法从哪个模块 b，c和 d实际上属于。

另一方面，如果你这样做:

#                   v  v  will know that these are from module1
from module1 import b, c   # way 1
import module2             # way 2


a = b + c - module2.d
#            ^ will know it is from module2

但是 ，最重要的是，在目前的现代计算机上，你永远不可能在 > 30英尺的速度下播放真正的1080p 视频(一张64位的1080p 图像需要15000Ko/14.9 MB)。其原因是由于采样/精度。视频游戏永远不会使用双精度(64位)的像素，图像，数据等。.而是使用较低的自定义精度(约4-8位) ，有时也使用较低的精度重新调整插值技术以允许合理的计算时间。

这对你来说更干净，而且新加入你的团队的人会有更好的主意。

还有其他技术，如剪切数据(使用 OpengL 标准和软件实现)、数据压缩等。还要记住，当前的 GPU 在硬件性能方面可以比当前的 CPU 快300倍。然而，一个好的程序员可能会得到10-20倍的因子，除非你的问题是完全优化和完全可并行的(特别是任务可并行)。

对于 第二点: 假设 module1和 module2都有作为 b的变量。当我这样做时:

from module1 import *
from module2 import *


print b  # will print the value from module2

根据经验，我可以告诉你优化就像一条指数曲线。为了达到最佳性能，所需的时间可能是非常重要的。

在这里，module1的值丢失了。即使 b是在 module1中声明的，并且我已经编写了期望我的代码使用 module1.b的代码，也很难调试为什么代码无法工作

因此，回到茶壶，您应该看到几何是如何表示，采样和精度 V 在 GTA 5看到，在几何学/纹理和最重要的，细节(精度，采样等)

DX 茶壶演示没有使用30% 的 CPU 做有用的工作。它忙于等待，因为它没有别的事情可做。