精华内容
下载资源
问答
  • unity WebGL

    千次阅读 2017-01-10 10:23:02
    自加入Unity WebGL平台以来,Unity的开发团队就一直致力于优化WebGL的内存消耗。我们已经在Unity使用手册上有对于WebGL内存管理的详尽分析,甚至在Unite Europe 2015与Unite Boston 2015两届大会上,也有专题对其...
    自加入Unity WebGL平台以来,Unity的开发团队就一直致力于优化WebGL的内存消耗。我们已经在Unity使用手册上有对于WebGL内存管理的详尽分析,甚至在Unite Europe 2015与Unite Boston 2015两届大会上,也有专题对其进行深入的讲解。然而,这方面的内容依旧是用户讨论的热门话题,因此我们意识到应当分享更多。希望本文能回答一些被频繁咨询的问题。
    

    Unity WebGL与其它平台有何不同?
    一些用户已经熟悉了部分内存有所限制的的平台。而对于其它如桌面和WebPlayer平台,到目前为止内存还不是问题。

    在内存方面,主机平台相对其它平台较为简单,因为您可以准确的知道内存是如何使用的。这允许您可以很好的管理内存,并保证您的游戏内容完美运行。在移动平台,内存管理变的有些复杂,因为设备种类繁多,但至少您可以选择最低标准的设备,并根据市场情况忽视那些相较于该标准更为的低端设备。

    在网页平台,就没有那么轻松了。理想情况下,所有终端用户都拥有64位浏览器和大量内存,但事实却相距甚远。首先,您无法通过任何方法知道,正运行您的内容的硬件规格。其次,除了用户的操作系统和浏览器外,您并不知道其它信息。最后,终端用户可能像运行其它网页一样运行您的WebGL内容。因此这是一个非常复杂的问题。

    概览

    下图是在浏览器上运行Unity WebGL内容时的内存概览:


    上图展示了Unity 堆,Unity WebGL内容将需要向浏览器请求额外分配的内存。这是理解WebGL内存管理的重点,从而让您优化项目得以将用户流失率降至最低。

    正如上图所示,存在几组内存分配:DOM,Unity堆,资源数据和代码,这些内容都会在网页加载时持久存在于内存中。而其它诸如 Asset Bundles, WebAudio 和 Memory FS 何时加载则取决于您的内容运行情况。(例如:Asset Bundle下载,音频播放等等)

    在加载期间, 一些浏览器在asm.js解析和编译时会产生临时内存分配,这偶尔也会导致部分使用32位浏览器的用户出现内存溢出的问题。

    Unity堆

    通常来说,Unity堆是指包含了所有Unity特有的游戏对象、组件、纹理、着色器 等等的内存块。

    在WebGL平台,Unity堆的大小需要提前获知,浏览器才能对此分配空间,并且内存空间一旦分配,就无法改变内存缓冲区大小。

    负责Unity 堆内存分配的代码如下:

    1.buffer = new ArrayBuffer(TOTAL_MEMORY);

    这段代码可以在所生成的build.js中找到,并通过浏览器的JS虚拟机来执行。

    TOTAL_MEMORY 是在Player Settings 中的WebGL Memory Size中设置的总内存。默认为256MB,但这是我们随意设定的值,事实上,一个空项目运行仅需16MB。

    然而,真实世界中游戏内容可能会需要更多的内存空间,大部分情况下都需要256或者386MB。请记住,项目需要的内存越多,能够运行它的终端用户就越少。

    源代码/编译代码内存

    在代码可以被执行之前,它需要如下步骤:
    • 下载
    • 复制到一个文本域
    • 编译

    请慎重考虑,上述的每一个步骤都将请求大量内存。因为:

    • 下载缓冲区是临时的,但是源代码和编译代码将持久存在于内存中。
    • 下载缓冲区和源代码大小,都是Unity所生成的未压缩的js大小。按照以下步骤,您可以估算它们需要多少内存:
      • 构建一个发布版本。
      • 将jsgz 、datagz重命名为*.gz文件,并通过压缩工具对它们进行解包。
      • 解压缩后的大小就是它们在浏览器内存中的大小。
    • 编译代码的大小取决于浏览器。

    优化内存的一个简单方法是启用Strip Engine Code,这样您发布的版本将不包含那些不必需的原生引擎代码(例如:如果不需要2D物理模块,它将被剥离)。请注意:托管代码一定会被剥离。

    千万要记住,异常捕捉和第三方插件也将增加代码大小。正如之前所说,我们已经注意到用户需要添加空值检查和数组边界检测的代码,但不希望完整的异常检测支持会带来过多的内存(及性能)消耗。要实现这点,您可以通过编辑器脚本传递 
    –emit-null-checks 和 –enable-array-bounds-check 到il2cpp,例如

    PlayerSettings.SetPropertyString("additionalIl2CppArgs", "--emit-null-checks --enable-array-bounds-check");

    最后请记住,构建开发版本产生的代码尺寸更大,因为它不曾缩减。这不是问题,毕竟最终交给用户的会是发布版。

    资源数据

    在其它平台上,一个应用可以简单地访问位于固定存储空间(硬盘,闪存等等)的文件。而在网页平台上这是不可能的,因为出于安全考虑,网页平台无法访问真正的文件系统。因此,Unity WebGL 数据(.data文件)一旦被下载,就会永远存储在内存中。这样做的缺点就是它相对其它平台将需要更多的内存(例如5.3中.data文件以lz4压缩的形式存储在内存中)。例如,下图是分析器显示的一个项目生成了约40MB的数据文件(在256MB Unity堆的设置下):



    .data 文件中包含了什么?它是Unity所生成的文件集合,包含以下内容:data.unity3d (所有的场景,它们依赖于Resources文件夹中的资源和所有内容),unity_default_resources和少量引擎所需的小文件。

    为了知晓资源的准确总大小,您需要在发布至WebGL平台后查看Temp\StagingArea\Data目录下的data.unity3d (Temp文件夹将会在Unity编辑器关闭时被删除)。另外,您也可以通过查看UnityLoader.js 中的DataRequest差值得知素材资源的准确大小。

    new DataRequest(0, 39065934, 0, 0).open('GET', '/data.unity3d');
    (这段代码根据Unity版本不同,写法可能有些区别——示例是Unity 5.4)

    内存文件系统
    虽然不存在真实的文件系统,正如前文所述,您的Unity WebGL内容仍然可以读写文件。相对于其它平台的主要区别在于,WebGL平台的文件输入/输出操作实际上都是对内存的读/写操作。很重要一点是,这个内存文件系统并不存在于Unity 堆中。因此,它将需要额外的内存。例如,下面这个输出数组到文件的示例:

    var buffer = new byte [10*1014*1024];

    File.WriteAllBytes(Application.temporaryCachePath + "/buffer.bytes", buffer);

    这个文件将会被写入到内存中,并且在浏览器的分析器也可以查看到。


    请注意:Unity堆的大小为256MB。

    同样,Unity的缓存系统依赖于文件系统,所以WebGL平台整个缓存存储也是在内存中进行的。这意味着像PlayerPrefs和缓存的Asset Bundles也会被持久化到内存中,而不存在于Unity堆中。

    Asset Bundles

    减少WebGL平台内存消耗的最佳方法之一是使用Asset Bundles (如果您对Asset Bundles不熟悉,请查阅Unity使用手册或通过教程学习)。然而,根据使用方式不同,它们将会对内存消耗带来巨大影响(Unity堆中和堆外都会受此影响),这将有可能导致您的内容无法运行在32位浏览器上。

    如果真的需要使用Asset Bundle,您会将所有资源打包到一个单独的Asset Bundle吗?

    千万别这么做!即使那样可能会减少网页加载期间的压力,您仍然需要下载(极可能无比巨大的)Asset Bundle,从而导致内存使用高峰。来看看下载AB前的内存使用情况。


    如您所见,256MB被分配给Unity堆。下图是没有经过缓存的Asset Bundle下载:


    现在看到的是额外的缓存,大约与硬盘中的Asset Bundle(约65mb)大小相同,它是通过XHR分配的。这只是一个临时缓存,但它将导致连续几帧的内存高峰,直至垃圾收集器启动。

    如何最小化内存高峰?为每个资源创建一个Asset Bundle?想法不错,但明显不合实际。

    事实上,对于如何做能够减少内存高峰并没有普遍的标准,这取决于您项目的实际需求。

    最后,在资源使用完毕后记得通过AssetBundle.Unload卸载Asset Bundle。

    Asset Bundle缓存

    Asset Bundle缓存与其它平台一样,您只需要使用WWW.LoadFromCacheOrDownload。它们最大的区别就是内存消耗。在Unity WebGL中,AB缓存依赖于IndexedDB,IndexedDB是由目前内存文件系统所支持的emscripten编译器实现。

    下图使用LoadFromCacheOrDownload下载Asset Bundle的内存使用情况:


    如您所见,Unity堆使用了512MB,并额外分配了约4MB的内存。

    下图是加载Asset Bundle后的内存情况:


    额外需要的内存跳到了约167mb。这是该Asset Bundle所需的额外内存(压缩包约为64mb)。下图是js虚拟机垃圾收集器启动后的内存情况:


    可以看到现在有了一些改善,但仍需约85mb的内存,其中大部分内存用于将Asset Bundle缓存到内存文件系统。这些内存即使卸载了Asset Bundle也不会回收。还有一点很重要,当玩家第二次在浏览器中运行游戏时,这些内存会被立即加载,甚至在加载Asset Bundle之前。

    下图是Chrome的内存截图以供参考:


    同样,在Unity堆外还有其它缓存相关的临时内存分配,以供Asset Bundle系统使用。坏消息是最近我们发现它比预想的更大。好消息是它将在未来的Unity 5.5 Beta 4,5.3.6 Patch 6和5.4.1 Patch 2中得以修复。

    对于更早的Unity版本,万一您的Unity WebGL内容已经上线或即将发布,而您又不想升级项目,一个快速的变通方法是通过编辑器脚本的设置以下属性:

    PlayerSettings.SetPropertyString("emscriptenArgs", " -s MEMFS_APPEND_TO_TYPED_ARRAYS=1", BuildTargetGroup.WebGL);

    最小化Asset Bundle缓存内存消耗的长远解决方案是,使用WWW构造器替代LoadFromCacheOrDownload(),或者您使用新的UnityWebRequest API 时,调用UnityWebRequest.GetAssetBundle()不要带有哈希或版本参数。

    其次是在XMLHttpRequest层使用替代的缓存机制,绕过内存文件系统,将下载的文件直接存储到indexedDB中。我们已经开发了这样的工具并发布在Asset Store中。您可以免费将它用于您的项目,也可以自定义以满足特殊需求。

    Asset Bundle压缩

    Unity 5.3和5.4均支持LZMA和LZ4两种压缩方式。然而,即使使用LZMA(默认)压缩相对于LZ4或未压缩下载的包更小,但它在WebGL平台上还是有些缺点:它会导致明显的运行延迟,并且需要更多的内存。因此强烈建议使用LZ4或者未压缩的格式(实际上,Unity 5.5的WebGL平台将不再支持对Asset Bundle的LZMA压缩),为了弥补相比LZMA压缩的下载尺寸过大,您可能希望使用gzip/brotli来压缩Asset Bundle,并配置到您的服务端。

    查阅Unity使用手册以获得更多关于Asset Bundle压缩的信息

    网页音频

    音频在Unity WebGL上的实现方式有所不同。这对内存意味着什么?

    Unity将会在JavaScript中创建特定的AudioBuffer的对象,以便它们可以通过WebAudio进行播放。

    由于WebAudio缓存位于Unity堆外,因此无法通过Unity 分析器进行跟踪分析,您需要使用浏览器专用的工具,来查看音频使用了多少内存。示例如下(火狐浏览器, about:memory page):


    考虑到那些Audio Buffers保存的是未解压的数据,其可能不适用于大型音频片段资源(例如:背景音乐)。对于那些资源,你可能希望自己编写js插件,以便使用<audio>标签。这种方式下音频文件会保持压缩,因此需要的内存更少。

    FAQ

    问:减少内存使用的最佳实践是什么?
    答:概括如下:
    • 减少Unity堆的大小
    • 尽可能保持“WebGL Memory Size”足够小
    • 减少代码量
    • 启用Strip Engine Code
    • 禁用异常检测
    • 避免使用第三方插件
    • 减少数据大小
    • 使用Asset Bundles
    • 使用Crunch纹理压缩

    问:是否存在能够决定最小WebGL Memory Size的策略?

    答:有,最佳策略是使用内存分析器,分析您的内容实际所需的内存大小,然后据此改变WebGL Memory Size。

    以空项目为例,内存分析器告诉我们总的使用量仅为16mb(这个值可能在不同Unity版本上有所不同):这意味着只须设置WebGL Memory Size大于16MB即可。当然,内存的总使用量将会依据您的内容而有所不同。

    然而,如果因为某些原因无法使用分析器,可以简单地通过不断地减少WebGL Memory Size 值,直到发现您的内容真正所需要的最小内存使用量为止。

    另外非常值得注意的是,任何不是16的倍数的值都将被自动的四舍五入(在运行时)为下一个16的倍数,这是Emscripten编译器所要求的。

    WebGL Memory Size(MB)设置将决定生成的html中TOTAL_MEMORY(bytes)的值。


    所以,为了在不重新构建项目的前提下,反复测试内存堆的值,推荐使用更改html的方式。一旦您通过此方式发现适合的值,只需在Unity项目设置中更改WebGL Memory Size即可。

    最后,记住Unity的分析器将占用一些来自Unity堆的内存,所以在使用分析器时可能需要增加WebGL内存大小。

    问:运行时发生内存溢出,如何修复?

    答:这取决于是Unity,还是浏览器的内存溢出。这个错误信息将会指出问题所在以及解决办法:“如果您是该内容开发者,请在WebGL设置中为您的应用分配更多(或更少)的内存。”此时您可以据此调整WebGL内存大小设置。然而还有很多可以解决内存溢出的方法。如果出现以下错误信息:


    除了消息内容,您还可以尝试减少代码和数据的大小。这是因为当浏览器加载网页时,它将试图为一些内容寻找空余的内存,其中最重要的是:代码,数据,Unity堆和被编译的asm.js。它们可能相当大,尤其是数据和Unity堆内存,这对32位浏览器来说可能是问题。

    在一些例子中,尽管存在足够多的空余内存,浏览器仍将加载失败,因为内存是碎片化的。这就是为什么有时候您的内容可能在重启浏览器之后,可以成功加载的原因。

    另一种情况是,当Unity 内存溢出时提示以下信息:


    在这种情况下,您需要优化您的Unity项目。

    问:如何衡量内存消耗?

    答:为了分析内容所使用的浏览器内存,可以使用火狐浏览器的内存工具或Chrome堆快照。但它们不会显示WebAudio内存使用情况,因此还可以获取火狐浏览器的about:memory页面快照,然后通过搜索“webaudio”找到。如果您需要通过JavaScript分析内存,请尝试使用window.performance.memory(只支持Chrome)。

    使用Unity分析器测量Unity堆内存使用。但请注意,您可能需要增加WebGL的内存大小,以便能够使用分析器。

    此外,我们一直在致力于开发一个新的工具,以便您能分析发布版本:构建WebGL版本,然后访问 http://files.unity3d.com/build-report/ 即可使用该工具。虽然这在Unity5.4下已经可用,但请您注意,这还是正在开发中的功能,并且随时会更改或被删除。但至少现在可以使用它达到测试的目的。

    问:WebGL Memory Size的最小值与最大值是多少?

    答:16MB是最小的,最大是2032MB,然而我们通常建议保持在512MB以下。

    是否可能出于开发目的而需要分配超过2032MB的内存?

    这是一个技术上的限制:2048MB(或更多)将会超出TypeArray所用的32位有符号整型的最大值,而TypeArray被用于在JavaScript中实现Unity堆。

    问:为何Unity 堆大小不可改变?

    答:我们一直在考虑使用Emscripten编译器标志ALLOW_MEMORY_GROWTH,来允许调整堆大小,但目前还是决定不用该标志,因为它会禁用一些Chrome中的优化。我们还未对这个影响做一些真正的基准测试。我们预计使用该标志可能会导致内存问题更严重。如果您遇到Unity堆过小,以至于无法满足所需内存的情况。这时就需要更多内存,那么浏览器就必须分配一个更大的堆,从旧堆中复制一切,然后再释放旧堆。这样做,它需要同时维持新堆和旧堆两份内存(直到完成复制),从而需要更多的总内存。因此,相比使用预定固定内存的方式内存占用更大。

    问:为什么32位浏览器在64位操作系统上会内存溢出?

    答:32位浏览器运行时的内存限制是一样的,无论操作系统是64或32位。

    结论

    最后建议使用浏览器专用的工具,来分析您的Unity WebGL内容,因为Unity分析器无法追踪超出Unity堆之外的内存分配。
    展开全文
  • unitywebgl中文输入框(无弹窗可中间插入输入)unitywebgl中文输入框(无弹窗可中间插入输入)unitywebgl中文输入框(无弹窗可中间插入输入)unitywebgl中文输入框(无弹窗可中间插入输入)unitywebgl中文输入框(无...
  • unitywebgl-源码

    2021-02-17 08:25:31
    unitywebgl
  • React Unity WebGL 在构建Web内容时,您可能需要与网页上的元素进行通信。 或者,您可能想使用默认情况下Unity当前未公开的Web API来实现功能。 在这两种情况下,您都需要直接与浏览器JavaScript引擎对接。 React...
  • unity webgl内存_了解Unity WebGL中的内存

    千次阅读 2020-09-13 18:45:55
    自从我们发布Unity WebGL以来,我们已经在优化内存消耗方面投入了大量精力。 在 手册中 以及在 2015年Unite欧洲 和 2015年 Unite波士顿的 演讲中, 我们还一直在解释内存在WebGL中的工作方式 。 但是,由于这一直是...

    unity webgl内存

    Since we shipped Unity WebGL, we have put a lot of effort into optimizing memory consumption. We’ve also been explaining how memory works in WebGL in the manual and in our talks at Unite Europe 2015 and Unite Boston 2015. However, as this continues to be a hot-topic in our conversation with customers, we realized we should talk more about it. Hopefully this post will answer some of the frequently asked question.

    自从我们发布Unity WebGL以来,我们已经在优化内存消耗方面投入了大量精力。 在 手册中 以及在 2015年Unite欧洲2015年 Unite波士顿的 演讲中, 我们还一直在解释内存在WebGL中的工作方式 。 但是,由于这一直是我们与客户交谈中的热门话题,因此我们意识到我们应该对此进行更多讨论。 希望这篇文章能回答一些常见问题。

    Unity WebGL与其他平台有何不同? (How is Unity WebGL different from other platforms ?)

    Some users are already familiar with platforms where memory is limited. For others, coming from desktop or the WebPlayer, this has never been an issue until now.

    一些用户已经熟悉内存受限的平台。 对于其他人,无论是来自台式机还是WebPlayer,到目前为止,这一直不是问题。

    Targeting console platforms is relatively easy in this respect, since you know exactly how much memory is available. That allows you to budget your memory and your content is guaranteed to run. On mobile platforms things are a bit more complicated because of the many different devices out there, but at least you can choose the lowest specs and decide to blacklist lower-end devices at the marketplace level.

    在这方面,定向控制台平台相对容易,因为您确切知道有多少可用内存。 这样您就可以预算内存,并保证内容可以运行。 在移动平台上,由于 那里存在 许多 不同的设备 ,因此情况 有些复杂 ,但是至少您可以选择最低规格的设备,并决定在市场级别将低端设备列入黑名单。

    On the Web, you simply can’t. Ideally, all end-users had 64-bit browsers and tons of memory but that’s far from reality. On top of that, there is no way to know the specs of the hardware your content is running on. You know the OS, Browser and not much more. Lastly, the end-user might be running your WebGL content as well as other web pages. That’s why this is a tough problem.

    在网络上,您根本做不到。 理想情况下,所有最终用户都具有64位浏览器和大量内存,但这与实际情况相去甚远。 最重要的是,您无法了解运行内容的硬件规格。 您知道操作系统,浏览器,仅此而已。 最后,最终用户可能正在运行您的WebGL内容以及其他网页。 这就是为什么这是一个棘手的问题。

    总览 (Overview)

    Here is an overview of memory when running Unity WebGL content in the browser:

    这是在浏览器中运行Unity WebGL内容时的内存概述:

    image04

    This image shows that on top of the Unity Heap, Unity WebGL content will require additional allocations in browser’s memory. That’s really important to understand, so that you can optimize your project and therefore minimize users drop-off rate.

    此图显示,在Unity Heap之上,Unity WebGL内容将需要在浏览器的内存中进行其他分配。 理解这一点非常重要,这样您就可以优化您的项目,从而最大程度地减少用户流失率。

    As you can see from the image, there are several groups of allocations: DOM, Unity Heap, Asset Data and Code which will be persistent in memory once the web page is loaded. Other ones, like Asset Bundles, WebAudio and Memory FS will vary depending on what’s happening in your content (e.g.: asset bundle download, audio playback, etc.).

    从图像中可以看到,有几组分配:DOM,Unity Heap,资产数据和代码,它们将在加载网页后永久保存在内存中。 其他内容(例如资产捆绑包,WebAudio和Memory FS)将根据您内容中发生的情况而有所不同(例如:资产捆绑包下载,音频播放等)。

    At loading-time, there are also several browser’s temporary allocations during asm.js parsing and compilation that sometimes cause out-of-memory problems to some users on 32-bit browsers.

    在加载时,在asm.js解析和编译期间,还有一些浏览器的临时分配,有时会给32位浏览器上的某些用户造成内存不足的问题。

    统一堆 (Unity Heap)

    In general, the Unity Heap is the memory containing all Unity-specific game objects, components, textures, shaders, etc.

    通常, Unity堆是包含所有特定于Unity的游戏对象,组件,纹理,着色器等的内存。

    On WebGL, the size of the Unity heap needs to be known in advance so that the browser can allocate space for it and once allocated, the buffer cannot shrink or grow.

    在WebGL上,需要预先知道Unity堆的大小,以便浏览器可以为其分配空间,并且一旦分配,缓冲区就不会缩小或增长。

    The code responsible for allocating the Unity Heap is the following:

    负责分配Unity堆的代码如下:

    1

    buffer = new ArrayBuffer(TOTAL_MEMORY);

    1

    buffer = new ArrayBuffer ( TOTAL_MEMORY ) ;

    This code can be found in the generated build.js, and will be executed by the browser’s JS VM.

    该代码可以在生成的build.js中找到,并将由浏览器的JS VM执行。

    TOTAL_MEMORY is defined by WebGL Memory Size in the Player Settings. The default value is 256mb, but that’s just an arbitrary value we chose. In fact an empty project works with just 16mb.

    TOTAL_MEMORY由“播放器设置”中的WebGL内存大小定义。 默认值为256mb,但这只是我们选择的任意值。 实际上,一个空项目仅占用16mb。

    However, real-world content will likely need more, something like 256 or 386mb in most cases. Keep in mind that the more memory is needed, the fewer end-users will be able to run it.

    但是,现实世界中的内容可能需要更多,在大多数情况下约为256mb或386mb。 请记住,需要的内存越多,最终用户运行它的数量就越少。

    源代码/编译后的代码存储器 (Source/Compiled Code memory)

    Before the code can be executed, it needs to be:

    在执行代码之前,它需要:

    1. downloaded.

      已下载。

    2. copied into a text blob.

      复制到文本Blob中。

    3. compiled.

      编译。

    Take into consideration that, each of these steps will require a chunk of memory:

    考虑到这些步骤中的每一个都将需要一块内存:

    • The size of the downloaded buffer and the source code are both the size of the uncompressed js generated by Unity. To estimate how much memory will be needed for them:

      下载缓冲区的大小和源代码都是Unity生成的未压缩js的大小。 估计它们将需要多少内存:

      • make a release build

        发布版本

      • rename jsgz and datagz to *.gz and unpack them with a compression tool

        将jsgz和datagz重命名为* .gz并使用压缩工具将其解压缩

      • their uncompressed size will also be their size in browser’s memory.

        它们的未压缩大小也将是它们在浏览器内存中的大小。

      The size of the downloaded buffer and the source code are both the size of the uncompressed js generated by Unity. To estimate how much memory will be needed for them:

      下载缓冲区的大小和源代码都是Unity生成的未压缩js的大小。 估计它们将需要多少内存:

    • The size of the compiled code depends on the browser.

      编译代码的大小取决于浏览器。

    An easy optimization is to enable Strip Engine Code so that your build will not include native engine code that you don’t need (e.g.: 2d physics module will be stripped if you don’t need it). Note: Note: Managed code is always stripped.

    一个简单的优化就是启用“剥离引擎代码”,以便您的构建中不包含不需要的本机引擎代码(例如:如果不需要,则将剥离2d物理模块)。 注意:注意:托管代码始终被剥离。

    Keep in mind that Exceptions support and third party plugins are going to contribute to your code size. Having said that, we have seen users that need to ship their titles with null checks and array bounds checks but don’t want to incur in the memory (and performance) overhead of full exception support. To do that, you can pass –emit-null-checks and –enable-array-bounds-check to il2cpp, for instance via editor script:

    请记住,异常支持和第三方插件将对您的代码大小有所帮助。 话虽如此,我们已经看到用户需要使用空检查和数组边界检查来交付其标题,但又不想招致完全异常支持的内存(和性能)开销。 为此,可以 通过编辑器脚本 将 –emit-null-checks–enable-array-bounds-check 传递给il2cpp:

    1

    PlayerSettings.SetPropertyString("additionalIl2CppArgs", "--emit-null-checks --enable-array-bounds-check");

    1

    PlayerSettings . SetPropertyString ( "additionalIl2CppArgs" , "--emit-null-checks --enable-array-bounds-check" ) ;

    Finally, remember that Development builds will produce larger code because it is not minified, though that’s not a concern since you are only going to ship release builds to the end user… right? ;-)

    最后,请记住,开发版本将产生更大的代码,因为它不会被缩减 ,尽管这不是问题,因为您只打算将发行版本交付给最终用户……对吗? ;-)

    资产数据 (Asset Data)

    On other platforms, an application can simply access files on the permanent storage (hard-drive, flash memory, etc…). On the web this is not possible since there is no access to a real file system. Therefore, once Unity WebGL data (.data file) is downloaded, it is then stored in memory. The downside is that it will require additional memory compared to other platforms (as of 5.3, the .data file is stored in memory lz4-compressed). For instance, here is what the profiler tells me about a project that generates a ~40mb data file (with 256mb Unity Heap):

    在其他平台上,应用程序可以简单地访问永久存储器(硬盘,闪存等)上的文件。 在网络上这是不可能的,因为无法访问真实的文件系统。 因此,一旦下载Unity WebGL数据(.data文件),然后将其存储在内存中。 缺点是,与其他平台相比,它将需要更多内存(从5.3开始,.data文件存储在lz4压缩的内存中)。 例如,以下是探查器告诉我的一个项目,该项目生成一个约40mb的数据文件(带有256mb的Unity Heap):

    image07

    What’s in the .data file ? It’s a collection of files that unity generates: data.unity3d (all scenes, their dependent assets and everything in the Resources folder), unity_default_resources and a few smaller files needed by the engine.

    .data文件中有什么? 它是unity生成的文件的集合:data.unity3d(所有场景,它们的从属资产以及Resources文件夹中的所有内容),unity_default_resources和引擎所需的一些较小文件。

    To know the exact total size of the assets, have a look at data.unity3d in Temp\StagingArea\Data after you built for WebGL (remember the Temp folder will be deleted when Unity editor is closed). Alternatively, you can look at the offsets passed to the DataRequest in UnityLoader.js:

    要了解资产的确切总大小,请在为WebGL构建后查看Temp \ StagingArea \ Data中的data.unity3d(请注意,关闭Unity编辑器后,Temp文件夹将被删除)。 或者,您可以查看在UnityLoader.js中传递给DataRequest的偏移量:

    1

    new DataRequest(0, 39065934, 0, 0).open('GET', '/data.unity3d');

    1

    new DataRequest ( 0 , 39065934 , 0 , 0 ) . open ( 'GET' , '/data.unity3d' ) ;

    (this code might change depending on the Unity version – this is from 5.4)

    (此代码可能会因Unity版本而异-从5.4开始)

    内存文件系统 (Memory File System)

    Although there is no real file system, as we mentioned earlier, your Unity WebGL content can still read/write files. The main difference compared to other platforms is that any file I/O operation will actually read/write in memory. What’s important to know is that this memory file system does not live in the Unity Heap, therefore, it will require additional memory. For instance, let’s say I write an array out to file:

    尽管没有真正的文件系统,但是正如我们前面提到的,您的Unity WebGL内容仍然可以读取/写入文件。 与其他平台相比的主要区别在于,任何文件I / O操作实际上都会在内存中进行读取/写入。 重要的是要知道该内存文件系统不在Unity Heap中,因此将需要额外的内存。 例如,假设我将一个数组写到文件中:

    1

    2
    3
    var buffer = new byte [10*1014*1024];
    File.WriteAllBytes(Application.temporaryCachePath + "/buffer.bytes", buffer);

    1

    2
    3
    var buffer = new byte [ 10 * 1014 * 1024 ] ;
    File . WriteAllBytes ( Application . temporaryCachePath + "/buffer.bytes" , buffer ) ;

    The file will be written to memory, which can also be seen in the browser’s profiler:

    该文件将被写入内存,这也可以在浏览器的探查器中看到:

    image12

    Note that Unity Heap size is 256mb.

    请注意,Unity Heap大小为256mb。

    Similarly, since Unity’s caching system depends on the file system, the whole cache storage is backed in memory. What does that mean? It means that things like PlayerPrefs and cached Asset Bundles will also be persistent in memory, outside of the Unity Heap.

    同样,由于Unity的缓存系统取决于文件系统,因此整个缓存存储都备份在内存中。 那是什么意思? 这意味着 PlayerPrefs 和缓存的资产捆绑包之 类的东西 也将在 Unity Heap之外的 内存中持久保存 。

    资产捆绑 (Asset Bundles)

    One of the most important best practices to reduce memory consumption on webgl, is to use Asset Bundles (If you are not familiar with them, you can check the manual or this tutorial to get started). However, depending on how they are used, there can be a significant impact on memory consumption (inside the Unity Heap and outside as well) that will potentially make your content not work on 32-bit browsers.

    减少webgl内存消耗的最重要的最佳实践之一是使用资产捆绑包(如果您不熟悉它们,可以查看 手册 或本 教程 以开始使用)。 但是,根据使用方式的不同,可能对内存消耗(在Unity Heap内部和外部)的内存使用产生重大影响,这可能使您的内容无法在32位浏览器上运行。

    Now that you know you really need to use asset bundles, what do you do? Dump all your assets into a single asset bundle?

    现在,您知道您确实需要使用资产捆绑包,您该怎么办? 将所有资产转储到单个资产捆绑中?

    NO! Even though that would reduce pressure at web-page loading time, you will still need to download (a potentially very big) asset bundle causing a memory spike. Let’s look at memory before the AB is downloaded:

    没有! 即使这样做可以减轻网页加载时的压力,您仍然需要下载(可能非常大)资产捆绑包,从而导致内存峰值。 让我们看一下下载AB之前的内存:

    image00

    As you can see, 256mb are allocated for the Unity Heap. And this is after downloading an asset bundle without caching:

    如您所见,Unity Heap分配了256mb。 这是在下载资产捆绑包而不进行缓存之后:

    image11

    What you see now is an additional buffer, approximately of the same size of the bundle on disk (~65mb), which was allocate by XHR. This is just a temporary buffer but it will cause a memory spike for several frames until it’s garbage collected.

    您现在看到的是一个额外的缓冲区,大约与磁盘上捆绑包的大小相同(〜65mb),由 XHR 分配 。 这只是一个临时缓冲区,但是它将导致几个帧的内存峰值,直到被垃圾回收为止。

    What to do then to minimize memory spikes? create one asset bundle for each asset? Although it’s an interesting idea, it’s not very practical.

    然后,如何最大程度地减少内存高峰? 为每个资产创建一个资产束? 尽管这是一个有趣的想法,但它不是很实用。

    The bottom line is that there is no general rule and you really need to do what makes more sense for your project.

    底线是没有通用规则,您确实需要做一些对您的项目更有意义的事情。

    Finally, remember to unload the asset bundle via AssetBundle.Unload when you are done with it.

    最后,请记住 在完成后 通过 AssetBundle 卸载资产束 。

    资产捆绑缓存 (Asset Bundle Caching)

    Asset Bundle caching works like it does on other platforms, you just need to use WWW.LoadFromCacheOrDownload. There is one pretty significant difference though, which is memory consumption. On Unity WebGL, AB caching relies on IndexedDB for storing data persistently, the problem is that the entries in the DB also exist in memory file system.

    Asset Bundle缓存的工作方式与其他平台一样,您只需要使用 WWW.LoadFromCacheOrDownload即可 。 但是有一个相当明显的区别,那就是内存消耗。 在Unity WebGL上,AB缓存依赖 IndexedDB持久存储数据 ,问题是DB中的条目也存在于内存文件系统中。

    Let’s look at a memory capture before downloading an asset bundle using LoadFromCacheOrDownload:

    在使用LoadFromCacheOrDownload下载资产捆绑包之前,让我们看一下内存捕获:

    image02

    As you can see, 512mb are used for the Unity Heap and ~4mb for other allocations. This is after loading the bundle:

    如您所见,Unity Heap使用512mb,其他分配使用〜4mb。 这是在加载捆绑包之后:

    image03

    The additional required memory jumped to ~167mb. That’s additional memory we need for this asset bundle (~64mb compressed bundle). And this is after js vm garbage collection:

    所需的额外内存跃升至167mb。 这是我们需要用于此资产捆绑包的额外内存(约64mb压缩捆绑包)。 这是在js vm垃圾回收之后:

    image13

    It’s a bit better, but ~85MB are still required: most of it is used to cache the asset bundle in memory file system. That’s memory you are not going to get back, not even after unloading the bundle. It’s also important to remember that when the user opens your content in the browser a second time, that chunk of memory is allocated right away, even before loading the bundle.

    稍微好一点,但是仍然需要约85MB:大部分用于将资产捆绑包缓存在内存文件系统中。 那是您将无法取回的内存,即使在卸载捆绑软件之后也是如此。 同样重要的是要记住,当用户第二次在浏览器中打开您的内容时,即使在加载捆绑包之前,也会立即分配该内存块。

    For reference, this is a memory snapshot from Chrome:

    作为参考,这是来自Chrome的内存快照:

    image09

    Similarly, there is another caching-related temporary allocation outside of the Unity Heap, that is needed by our asset bundle system. The bad news is that we recently found it is much larger than intended. The good news though, is that this is fixed in the upcoming Unity 5.5 Beta 4, 5.3.6 Patch 6 and 5.4.1 Patch 2.

    类似地, Unity Heap之外 还有另一个与缓存相关的临时分配 ,这是我们的资产捆绑系统所需的。 坏消息是我们最近发现它比预期的要大得多。 好消息,虽然,是,这是固定在即将到来的统一 5.5 Beta 4的5.3.6补丁65.4.1补丁2

    For older versions of Unity, in case your Unity WebGL content is already live or close to release and you don’t want to upgrade your project, a quick workaround to set the following property via editor script:

    对于较旧版本的Unity,如果您的Unity WebGL内容已经发布或即将发布,并且您不想升级项目,则可以通过编辑器脚本设置以下属性的快速解决方法:

    1

    PlayerSettings.SetPropertyString("emscriptenArgs", " -s MEMFS_APPEND_TO_TYPED_ARRAYS=1", BuildTargetGroup.WebGL);

    1

    PlayerSettings . SetPropertyString ( "emscriptenArgs" , " -s MEMFS_APPEND_TO_TYPED_ARRAYS=1" , BuildTargetGroup . WebGL ) ;

    A longer term solution to minimize asset bundle caching memory overhead is to use WWW Constructor instead of LoadFromCacheOrDownload() or use UnityWebRequest.GetAssetBundle() with no hash/version parameter if you are using the new UnityWebRequest API.

    最小化资产捆绑缓存内存开销的长期解决方案是使用 WWW构造函数 而不是 LoadFromCacheOrDownload(), 或者 如果使用新的 UnityWebRequest API, 则使用不带哈希/版本参数的 UnityWebRequest.GetAssetBundle()

    Then use an alternative caching mechanism at the XMLHttpRequest-level, that stores the downloaded file directly into indexedDB, bypassing the memory file system. This is exactly what we have developed recently and it is available on the asset store. Feel free to use it in your projects and customize it if you need to.

    然后,在XMLHttpRequest级别使用替代的缓存机制,该机制将下载的文件直接存储到indexedDB中,从而绕过内存文件系统。 这正是我们最近开发的,可以在 资产商店中找到 。 随意在项目中使用它,并根据需要自定义它。

    资产捆绑压缩 (Asset Bundle Compression)

    In 5.3 and 5.4, both LZMA and LZ4 compressions are supported. However, even though using LZMA (default) results in smaller download size compared to LZ4/Uncompressed, it has a couple of downsides on WebGL: it causes noticeable execution stalls and it requires more memory. Therefore, we strongly recommend to use LZ4 or no compression at all (as a matter of fact, LZMA asset bundle compression will not be available for WebGL as of Unity 5.5), and to compensate for the larger download size compared to lzma, you may want to gzip/brotli your asset bundles and configure your server accordingly.

    在5.3和5.4中,都支持LZMA和LZ4压缩。 但是,即使使用LZMA(默认)与LZ4 /未压缩相比,下载量较小,但在WebGL上也有一些缺点:它会导致明显的执行停顿,并且需要更多的内存。 因此,我们强烈建议您使用 LZ4根本不 使用 压缩 (事实上​​,从Unity 5.5开始,LZMA资产捆绑包压缩将不适用于WebGL),并且为了补偿比lzma更大的下载大小,您可以想要gzip / brotli您的资产捆绑包并相应地配置服务器。

    See the manual for more information about asset bundle compression.

    有关 资产束压缩的 更多信息,请参见手册 。

    网络音频 (WebAudio)

    Audio on Unity WebGL is implemented differently. What does that mean for memory?

    Unity WebGL上的音频实现方式 有所不同 。 这对记忆意味着什么?

    Unity will create specific AudioBuffer’s objects in JavaScript land, so that they can be played via WebAudio.

    Unity将 在JavaScript领域中 创建特定 AudioBuffer 的对象,以便可以通过WebAudio播放它们。

    Since WebAudio buffers live outside the Unity Heap and therefore cannot be tracked by the Unity profiler, you need to inspect memory with browser-specific tools to see how much memory is used for audio. Here’s an example (using Firefox about:memory page):

    由于 WebAudio缓冲区活统一堆之外,因此无法通过统一探查器进行跟踪, 您需要检查与特定浏览器的工具穿线 Ø看到多少内存用于音频 存储器 。 这是一个示例(使用Firefox about:memory 页面):

    image08

    Take into consideration that these Audio Buffers hold uncompressed data, which might not be ideal for large audio clip assets (e.g.: background music). For those, you may want to consider writing your own js plugin so that you can use <audio> tags instead. This way audio files remain compressed, therefore use less memory.

    请注意,这些音频缓冲区包含未压缩的数据,这对于大型音频片段资产(例如背景音乐)可能不是理想的选择。 对于这些,您可能要考虑编写自己的js插件,以便可以使用<audio>标记代替。 这样,音频文件保持压缩状态,因此占用的内存更少。

    常问问题 (FAQ)

    减少内存使用的最佳实践是什么? (What are the best practices to reduce memory usage ?)

    Here is a summary:

    总结如下:

    1. Reduce the size of the Unity Heap:

      减小Unity Heap的大小:

      • Keep the ‘WebGL Memory size’ as small as possible

        保持“ WebGL内存大小”尽可能小

      Reduce the size of the Unity Heap:

      减小Unity Heap的大小:

    2. Reduce your code size:

      减少代码大小:

      • Enable Strip Engine Code

        启用脱机引擎代码

      • Disable Exceptions

        禁用例外

      • Try to avoid usage of 3rd party plugins

        尽量避免使用第三方插件

      Reduce your code size:

      减少代码大小:

    3. Reduce your Data size:

      减少数据大小:

      • Use Asset Bundles

        使用资产捆绑包

      • Use Crunch texture compression

        使用Crunch纹理压缩

      Reduce your Data size:

      减少数据大小:

    是否有确定WebGL内存大小的策略? (Is there a strategy for determining how small WebGL Memory Size can be ?)

    Yes, the best strategy would be to use the memory profiler and analyse how much memory your content actually requires, then change WebGL Memory Size accordingly.

    是的,最好的策略是使用内存分析器并分析您的内容实际需要多少内存,然后相应地更改WebGL内存大小。

    Let’s take an empty project as an example. The Memory Profiler tells me that “Total Used” amounts to just over 16MB (this value might differ between releases of Unity): that means I must set WebGL Memory Size to something bigger than that. Obviously, “Total Used” will be different based on your content.

    让我们以一个空项目为例。 Memory Profiler告诉我,“ Total Used”总计刚刚超过16MB(此值在Unity版本之间可能有所不同):这意味着我必须将WebGL Memory Size设置为大于此值。 显然,“总使用量”将根据您的内容而有所不同。

    However, if for some reason you cannot use the Profiler, you could simply keep reducing the WebGL Memory Size value until you find the minimum amount of memory required to run your content.

    但是,如果由于某种原因无法使用Profiler,则可以简单地继续减小WebGL内存大小值,直到找到运行内容所需的最小内存量。

    It’s also important to note that any value that is not a multiple of 16 will be automatically rounded (at run-time) to the next multiple as this is an Emscripten requirement.

    同样重要的是要注意,任何不是16的倍数的值都将在运行时自动舍入到下一个倍数,因为这是Emscripten的要求。

    WebGL Memory Size (mb) setting will determine the value of TOTAL_MEMORY (bytes) in the generated html:

    WebGL内存大小(mb)设置将确定所生成的html中的T​​OTAL_MEMORY(字节)值:

    screenshot-2016-09-20-11-56-47

    So, to iterate on the size of the heap without re-building the project, it is recommended to modify the html. Then, once you found a value you are happy with, you can change the WebGL Memory Size in the Unity project.

    因此,要在不重新构建项目的情况下迭代堆的大小,建议修改html。 然后,一旦找到满意的值,就可以在Unity项目中更改WebGL内存大小。

    Thankfully this is not the only way and the next blog post on the Unity heap will try to provide a better answer to this question.

    幸运的是,这不是唯一的方法, 有关Unity堆的下一篇博客文章将尝试为该问题提供更好的答案。

    Finally, remember that Unity’s profiler will use some memory from the allocated Heap, so you might need to increase WebGL Memory Size when profiling.

    最后,请记住,Unity的探查器将使用分配的堆中的一些内存,因此在进行性能分析时可能需要增加WebGL内存大小。

    我的构建内存不足,如何解决? (My build runs out-of-memory, how can I fix it ?)

    It depends on whether it’s Unity running out of memory or the browser. The error message will indicate what the problem is and how to solve it: “If you are the developer of this content, try allocating more/less memory to your WebGL build in the WebGL player settings.” Then you can adjust the WebGL Memory Size setting accordingly. However, there’s more you can do to solve the OOM. If you get this error message:

    这取决于是Unity内存不足还是浏览器不足。 该错误消息将指示问​​题是什么以及如何解决该问题: “如果您是此内容的开发者,请 尝试 在WebGL播放器设置中为WebGL构建 分配更多/更少的内存 。” 然后,您可以相应地调整WebGL内存大小设置。 但是,您可以做更多的事情来解决OOM。 如果收到此错误消息:

    image01

    In addition to what the message says, you can also try to reduce the size of code and/or data. That’s because when the browser loads the web page, it will try to find free memory for several things, most importantly: code, data, unity heap and compiled asm.js. They can be quite large, especially Data and Unity heap memory, which can be a problem for 32-bit browsers.

    除了显示消息外,您还可以尝试减少代码和/或数据的大小。 这是因为,当浏览器加载网页时,它将尝试为以下几项寻找可用内存,其中最重要的是:代码,数据,统一堆和已编译的asm.js。 它们可能很大,尤其是Data和Unity堆内存,这对于32位浏览器可能是个问题。

    In some instances, even though there is enough free memory, the browser will still fail because the memory is fragmented. That’s why, sometimes, your content might succeed to load after you restart the browser.

    在某些情况下,即使有足够的可用内存,浏览器仍然会因为内存碎片而失败。 因此,有时在重新启动浏览器后,您的内容可能会成功加载。

    The other scenario, when Unity runs out-of-memory, will prompt a message like:

    当Unity的内存不足时,另一种情况将提示如下消息:

    image05

    In this case you need to optimize your Unity project.

    在这种情况下,您需要优化Unity项目。

    如何测量内存消耗? (How do I measure memory consumption?)

    To analyze browser’s memory used by your content, you can use Firefox Memory Tool or Chrome Heap snapshot. Though, be aware that they will not show you WebAudio memory, for that you can use about:memory page in Firefox: take a snapshot, then search for “webaudio”. If you need to profile memory via JavaScript, try window.performance.memory (Chrome-only).

    要分析您的内容使用的 浏览器 内存 ,您可以使用 Firefox 内存工具 或Chrome Heap快照 。 但是,请注意,它们不会显示WebAudio内存,因此您可以 在Firefox中 使用 about:memory 页面:拍摄快照,然后搜索“ webaudio”。 如果您需要通过JavaScript配置内存,请尝试 window.performance.memory (仅适用于Chrome)。

    To measure memory usage inside the Unity Heap, use the Unity Profiler. Though, be aware that you might need to increase WebGL Memory Size, in order to be able to use the profiler.

    要测量Unity Heap内部的内存使用情况,请使用Unity Profiler。 但是,请注意,为了能够使用事件探查器,可能需要增加WebGL内存大小。

    In addition, there is a new tool we have been working on that allows you to analyze what’s in your build: To use it, make a WebGL build, then visit http://files.unity3d.com/build-report/. Although this is available as of Unity 5.4, note that this functionality is a work-in-progress and subject to change or being removed at any time. But we are making it available for testing purposes for now.

    此外,还有一个我们正在使用的新工具,可让您分析构建中的内容:要使用它,请进行WebGL构建,然后访问 http://files.unity3d.com/build-report/ 。 尽管此功能自Unity 5.4起可用,但请注意,此功能尚在开发中,随时可能更改或删除。 但是我们现在将其用于测试目的。

    WebGL内存大小的最小/最大值是多少? (What’s the minimum/maximum value of WebGL Memory Size ?)

    16 is the minimum. The maximum is 2032, however, we generally advise to stay below 512.

    最小为16。 最大值为2032,但是,我们通常建议保持在512以下。

    是否可以为开发目的分配2032 MB以上的内存? (Is it possible to allocate more than 2032 MB for development purposes ?)

    This is a technical limitation: 2048 MB (or more) will overflow the 32-bit signed integer size of the TypeArray used to implement the Unity heap in JavaScript.

    这是一个技术限制:2048 MB(或更多)将溢出用于在JavaScript中实现Unity堆的TypeArray的32位带符号整数大小。

    为什么不能使Unity Heap可调整大小? (Why can’t you make the Unity Heap resizable ?)

    We have been considering using the ALLOW_MEMORY_GROWTH emscripten flag to allow the Heap to be resized, but so far decided not to because doing so would disable some optimizations in Chrome. We have yet to do some real benchmarking on this impact of this. We expect that using this might actually make memory issues worse. If you have reached a point where the Unity Heap is too small to fit all the required memory, and it needs to grow, then the browser would have to allocate a bigger heap, copy everything over from the old heap, and then deallocate the old heap. By doing so, it needs memory for both the new and the old heap at the same time (until it finished copying), thus requiring more total memory. So the memory usage would be higher than when using a predetermined fixed memory size.

    我们一直在考虑使用ALLOW_MEMORY_GROWTH emscripten标志来允许调整堆的大小,但是到目前为止,我们决定不这样做,因为这样做会禁用Chrome中的某些优化。 我们尚未对此产生的影响做一些实际的基准测试。 我们希望使用此方法实际上会使内存问题更严重。 如果您已经达到Unity Heap太小而无法容纳所有所需内存的程度,并且需要增长,那么浏览器将不得不分配一个更大的堆,从旧堆中复制所有内容,然后释放旧的堆。堆。 这样,它同时需要新堆和旧堆的内存(直到完成复制),因此需要更多的总内存。 因此,与使用预定的固定内存大小时相比,内存使用率会更高。

    为什么32位浏览器在64位OS上内存不足? (Why does a 32-bit browser run out-of-memory on a 64-bit OS ?)

    32-bit browsers will run into the same memory limitations regardless of whether the OS is 64 or 32-bit.

    不管操作系统是64位还是32位,32位浏览器都将遇到相同的内存限制。

    结论 (Conclusions)

    The final recommendation is to profile your Unity WebGL content using browser-specific tools as well, because as we described there are allocations outside of the Unity Heap that Unity’s profiler cannot track.

    最终的建议是也使用特定于浏览器的工具来分析您的Unity WebGL内容,因为正如我们所描述的,Unity探查器无法跟踪Unity堆之外的分配。

    Hopefully, some of this information will be useful to you. If you have further questions, please don’t hesitate to ask them here or in the WebGL forum.

    希望其中的一些信息对您有用。 如果您还有其他问题,请随时在这里或在 WebGL论坛中 提问 。

    Update:

    更新:

    We talked about memory used for code and we mentioned that the source JS code is copied into a temporary text blob. What we discovered is that the blob was not properly deallocated so effectively it was a permanent allocation in browser memory. In about:memory, it’s labelled as memory-file-data:

    我们讨论了用于代码的内存,并提到将源JS代码复制到临时文本Blob中。 我们发现, 无法正确有效地重新分配 Blob ,这是浏览器内存中的永久分配。 在about:memory中,它被标记为memory-file-data:

    image08

    Its size is dependent on the code size and for complex projects can easily be 32 or 64mb. Thankfully, this has been fixed in 5.3.6 Patch 8, 5.4.2 Patch 1 and 5.5.

    它的大小取决于代码的大小,对于复杂的项目,大小很容易为32或64mb。 幸运的是, 他的 吨 已固定在 5.3.6补丁85.4.2补丁1 和5.5。

    In terms of Audio, we know that memory consumption is still a problem: Audio streaming is not currently supported and audio assets are currently kept in Browser memory as uncompressed. So we suggested to use <audio> tag to playback large audio files. For this purpose we recently published a new Asset Store package to help you minimize memory consumption by streaming audio sources. Check it out!

    在音频方面,我们知道内存消耗仍然是一个问题:当前不支持音频流,并且音频资产当前以未压缩的方式保存在浏览器内存中。 因此,我们建议使用<audio>标记来播放大型音频文件。 为此,我们最近发布了一个新的Asset Store 软件包, 以帮助您通过流音频源来最大程度地减少内存消耗。 看看这个!

    翻译自: https://blogs.unity3d.com/2016/09/20/understanding-memory-in-unity-webgl/

    unity webgl内存

    展开全文
  • UnityWebGL文件选择.unitypackage
  • Unity WebGL

    2017-02-09 23:01:00
    Unity导出WebGL不支持c#socket和unity的network 可以用javascript的websocket实现。。。 c#一般通过www从phpserver获取。。。 注意事项: http://www.cnblogs.com/bnudc/articles/5295665.html 参考方法: ...

    路过弄了个unity
    Unity导出WebGL不支持c#socket和unity的network
    可以用javascript的websocket实现。。。
    c#一般通过www从phpserver获取。。。
    注意事项:
    http://www.cnblogs.com/bnudc/articles/5295665.html

    参考方法:
    https://forum.unity3d.com/threads/webgl-and-mysql.376556/?_ga=1.58183914.1558616045.1485175429
    https://docs.unity3d.com/Manual/webgl-networking.html
    http://wiki.unity3d.com/index.php/Server_Side_Highscores

    转载于:https://www.cnblogs.com/HaibaraAi/p/6384545.html

    展开全文
  • unity webgl js demo.zip

    2021-07-20 12:00:57
    unity WEBGL demo案例
  • React Unity WebGL通过将React和Unity应用程序之间的双向通信与高级API结合起来,为将Unity WebGL构建嵌入到React应用程序中提供了一个简单的解决方案。 ≪···≫ 你好! 我叫Jeffrey Lanters,感谢您的光临! ...
  • UnityWebGL_StageRun-源码

    2021-02-18 08:41:47
    UnityWebGL_StageRun
  • unity Webgl播放视屏

    2020-12-03 16:48:13
    Unity WebGl播放视屏
    1. 采用unity自带的Video player视屏播放组件,在webgl端为了使导出包体最大化减少大小,视屏内容放到StreamingAssets特殊文件夹下,他会把文件夹内资源不压缩导出包体,但不会再加载webgl时,加载到这部分内容. 代码获取StreamingAssets路径:Application.streamingAssetsPath

    2. 在ui画布下创建一个Video Player组件,里面的视屏加载方式改为Url加载,或者通过代码给video player设置url路径.Video player里面的wait For First Frame不能选中,选中这个后在webgl端视屏会黑屏,不清楚具体是啥原因,不选中就不会黑屏,会正常播放视屏.

       

    3.  在webgl端Video Player里面的视屏的不能开始自动播放,需要手动去调用player()方法,播放视屏.
    4. 如果有切换视屏,开头会出现上个视屏缓存的问题,可以另外一个笔记.

     

    展开全文
  • Unity Webgl播放直播功能源码及运行文件
  • Unity-WebGL-实用程序 基于Unity团队的博客文章和WebGL Essentials资产包并从中获得启发的Unity WebGL游戏的一些有用实用程序。 正在安装 获取并将unitypackage导入到您的项目中。 WebGLMemoryStats 这是一种简单的...
  • Unity WebGL内存:Unity

    2020-09-13 22:05:38
    unity webgl内存 在先前的Unity WebGL 博客文章中 ,我们解释了与其他平台相比,内存的工作方式有所不同。 我们告诉您Unity Heap应该尽可能小,并且我们还强调了浏览器内存中还有其他分配。 (In the previous Unity ...
  • UnityWEBGL打包失败问题

    2021-08-20 14:51:03
    UnityWEBGL打包失败问题 UnityWebGL打包时报错Unity安装目录下python.exe运行失败, 解决方法:将当前工程目录下Library下的webgl_cache文件删除后重新打开项目打包即可
  • Unity Webgl 问题总结

    千次阅读 热门讨论 2020-06-16 15:19:39
    Unity Webgl 问题总结 最近公司要求将CS项目更改成BS项目,我听后人都傻了,对这块不是很熟悉,之前没有做过完整的项目,只知道unity webgl有很多坑,然后只能去网上找找资料,发现unitywebgl平台对开发者实在是太...
  • 通过调取Js方法实现Unity WebGL 屏幕截屏(相机全屏)及下载成jpeg图片,demo文件测试时截图下载位置是浏览器默认下载路径,如要指定下载路径,打开浏览器设置的下载时询问下载地址即可。当前demo下载文件格式是jpg...
  • Unity WebGL Vue

    2021-04-21 17:26:33
    Vue项目内嵌WebGL 基于vue-element-admin开发,使用Unity2020.3.1。 不了解前端项目,当时随便找了一个前端框架,这个框架值得学习,...一、Unity WebGL WebGL文档 2020.3 1. C#和js交互 自行查看官方文档和示例,由于
  • Unity WebGL打包发布时在Building native binary with IL2CPP...报错:Failed running D:DownloadAppsUnity2019.4.8f1EditorDatail2cpp/build/deploy/...
  • UnityWebGL播放视频两种方案, 第一种方案,AVProVideo,非webgl也可用 第二张方案,使用html的内嵌网页
  • Unity WebGL应用程序的响应式布局模板,适用于比应用程序本身运行更多的网站。 如何使用 在Unity项目的Assets文件夹中创建一个名为WebGLTemplates的文件夹。 对于Unity 2018和2019,将responsive-template文件夹...
  • 适用于Unity WebGL的IME(支持Unity2018.2中的TextMesh Pro) 支持“复制粘贴” 支持“ tab”和“ shift + tab”将焦点更改为其他InputField 支持手机。 (实验) 演示 如何使用 1.下载并导入到项目 2.将“ ...
  • 一个unity WebGL项目(含全部源代码).欢迎学习
  • Unity WebGL踩坑记录

    2021-10-21 11:02:01
    Unity WebGL踩坑记录 浏览器静态网页访问: 使用Google:属性后添加空格--allow-file-access-from-files 加载一直不动,浏览器F12报错:Framework is not defined: 导出项目的时候,发布设置:压缩格式选择已禁用 ...
  • webgl unity 去年,我们在WebGL上发布了一系列技术博客文章,从内存中的几篇文章开始。 现在是时候继续一个新主题了。 您是否曾经需要/想要重复使用网页中的现有C / C ++代码? 也许是用OpenGL ES编写的图形效果? ...
  • unity WebGL射线检测

    2021-02-02 09:10:49
    unity WebGL射线检测 unity 打包WebGL射线检测不到网格碰撞器,百度找到以下说法: web平台射线检测网格碰撞器不灵敏,经常出错,解决方案:Publishing Settings 中的 LinkerTarget属性设置为WebAssembly 本人用的...
  • Unity Webgl 发布错误

    2017-03-15 09:16:03
    Unity Webgl 发布时,弹出以下错误,不知道是什么原因,请各位路过的大神帮我看看吧,谢谢啦 ![图片说明](https://img-ask.csdn.net/upload/201703/15/1489569119_300744.jpg)
  • UnityWebgl知识总结

    2020-03-29 19:57:21
    Unity WebGL发布的项目不能在火狐浏览器打开! 安装UnityWebPlayer 配置浏览器设置
  • Unity WebGL版,背景透明化(画布透明),显示Html网页背景。内含Demo和项目文件。unity版本2018.4.2,测试通过。
  • unity webGL在3D物体上播放视频,有播放暂停,滑动条控制视频播放进度的功能。注意:仅支持webGL在3D物体播放视频,编辑状态看不出效果,需发布出来测试!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,489
精华内容 1,795
关键字:

unitywebgl