Unity 2018.1 marked the start of a new cycle with two major innovations at the core. Together, the Scriptable Render Pipeline (SRP) and Shader Graph give artists and developers more power, while the C# Job System, Burst Compiler and ECS make it possible to take advantage of multi-core processors without the programming headache. Unity 2018.2 builds on these innovations and adds several new features. This post provides an overview of the most important updates in 2018.2. While you go through the list of new features, you can or via the Unity Hub. One of the goals for Unity 2018.2 has been to build on the Scriptable Render Pipelines (SRPs) in order to enable next-level rendering. Another focus area has been to develop a range of features and improvements that will help you succeed in mobile.
- Cio.com Ar Twitter: First Look: Visual Studio For Mac Mac
- Cio.com Ar Twitter First Look Visual Studio For Mac
From breaking news and entertainment to sports, politics, and everyday interests, when it happens in the world, it happens on Twitter first. See all sides of the story. Join the conversation. Twitter is what's happening in the world and what people are talking about right now.
Let’s take a brief look at what we’ve done in these two areas before going into more detail on the entire release. Unity 2018.2 optimizes the performance of the Lightweight Render Pipeline (LWRP) and enhances the High Definition Render Pipeline (HDRP) to help you achieve high-end visual quality, including multiple improvements to the Shader Graph, which now supports both pipelines (please note that both the LWRP and HDRP are currently in preview.) We also added support for managed code debugging on iOS and Android, Windows, macOS, Nintendo Switch, UWP and PS4 for IL2CPP, and we started adding some mobile optimizations to the Lightweight Render Pipeline (LWRP). For Android projects, 64-bit (ARM64) support gets its final release, and we now let you add Java code to your Unity plugins folder without needing to create libraries in advance.
Finally, several new 2D features are available as Preview packages, including the Vector Graphics importer and Pixel Perfect. The Vector Graphics importer makes it easier for you to work with SVG graphics, and Pixel Perfect makes it easier for you to achieve a perfect retro look across different resolutions on a wide range of devices.
To get an overview of all the improvements in this release, read on. What’s new in Unity 2018.2 Give me all the details Graphics Scriptable Render Pipeline (SRP) improvements In 2018.1, we introduced the Scriptable Render Pipeline (in preview), which places control of powerful new rendering pipelines in the hands of artists and developers.
This release includes the following SRP updates: SRP batcher Speeds up CPU rendering The SRP batcher is a new Unity engine inner loop that speeds up CPU rendering without affecting GPU performance. It replaces legacy SRP rendering code. Games that use Physically Based Rendering (PBR) often have many different objects and meshes that share the same shader and keywords for all the different materials per object. The SRP batcher gives games that use PBR a major CPU speed boost. The SRP batcher works with the High Definition Render Pipeline (HDRP) and Lightweight Render Pipeline (LWRP), with PC DirectX-11, Metal and PlayStation 4 currently supported. Scriptable shader variants stripping Reduces player build time and data size Player build time and data size increase with the complexity of your project because of the increased number of shader variants.
With scriptable shader variants stripping, introduced in 2018.2, you can manage the number of shader variants generated and therefore drastically reduce player build time and data size. This feature allows you to strip all the shader variants with invalid code paths and/or unused features, and to create shader-build configurations, such as “debug” and “release,” without affecting iteration time or maintenance complexity. Scriptable shader variants stripping can lead to a massive increase in team efficiency. To learn more about how scriptable shader variants stripping is implemented in the Unity shader pipeline architecture. Shader variants stripping options in the GraphicsSettings Lightweight Render Pipeline (Preview) Delivers high performance The Lightweight Render Pipeline (LWRP) delivers high performance, which is especially useful for lower-end hardware, performance-hungry applications like XR, and platforms, such as mobile. LWRP improves performance and optimization further with Optimized Tile utilization. LWRP will adjust the number of load-and-store to tiles in order to optimize the memory of mobile GPUs.
It also shades light in batches, which reduces overdraw and draw calls. Basic LWRP is currently supported on all VR platforms, however, it will not support Multisample anti-aliasing (MSAA) until 2018.3. Please note that LWRP is currently not supported for handheld AR, like ARCore or ARKit, or HoloLens or Magic Leap devices.
New product plans will be communicated at a future date. The LWRP delivers high performance for lower-end HW and performance-hungry apps like XR.
High Definition Render Pipeline (Preview) First shipped as a Preview in 2018.1, the High Definition Render Pipeline (HDRP) prioritizes high-definition visuals targeting primarily high-end platforms, such as PC and consoles. In 2018.2, we have gone further to help you achieve high-end visual quality. However, it is important to note that the SRPs are still Previews, and consequently not yet recommended or supported for production. Improvements include volumetrics, glossy planar reflection, Geometric specular AA, and Proxy Screen Space Reflection & Refraction, Mesh decals, and Shadow Mask. Volumetrics: Volumetric fog receives lighting from all supported light types except area light. It is also possible to control the density of the fog locally with density volume.
Glossy planar reflection: Planar reflection now supports glossy reflection, which means that it takes into account the smoothness of the material. Geometric specular AA: Mesh with dense numbers of triangles can cause specular aliasing. In order to address this, there is now an option to reduce and limit the amount of aliasing. Proxy Screen Space Reflection & Refraction: This feature lets you use proxy volume (volume approximating the scene boundary) to perform screen-space reflection and refraction. While it is not as accurate as using the depth buffer, the runtime cost is lower.
Mesh decals: This allows you to use mesh for decals in addition to projector decals. Shadow mask: Previously, this feature in HDRP used the Distance Shadowmask mode (dynamic shadow fade to shadow mask at maximum shadow distance). With 2018.2, it is now possible to select per light if the dynamic shadow only renders a non-lightmapped object (corresponding to the shadow mask mode of the built-in pipeline). So unlike with the built-in pipeline, HDRP allows both shadow-mask modes to be enabled at the same time, and you have a per-light control for the built-in Shadow mask mode. Additionally, we have added limited Shader Graph support so you can visually create shaders, and we are working to improve overall stability and performance. Limited support means that only a subset of HDRP features is available in the Shader Graph.
There are currently no advanced material features (SSS, clear coat), and tessellation is not currently available either. Lastly, we have added a shader stripping feature, which makes it possible to avoid compiling shaders that are not required when building a player. This results in a much faster build time. Please note the HDRP is not currently supported on any AR or VR platforms. Support for these platforms is scheduled for 2019.
New product plans will be communicated at a future date. Fontainebleau Photogrammetry demo with volumetric light shaft from Sunlight. The HDRP was instrumental for creating this entire car commercial in Unity Progressive Lightmapper There are several improvements to the Progressive Lightmapper, which came out of Preview in 2018.1. Configurable baked light falloff The configurable falloff in the Progressive Lightmapper enables you to match physically plausible falloff curves when baking your lights.
Previously, the observed intensity of spot and point lights was greatly affected by the range value of the light. This is not physically plausible because the falloff distance (or attenuation) of a light in reality is determined by its intensity. This feature allows the Progressive Lightmapper to decouple range and intensity by having a distance falloff that is tied to world-space distance. While legacy falloff is still supported, we now also support linear falloff, distance squared, and distanced squared with attenuation to zero at the range limits. Inverse square falloff is enabled by default in HDRP in order to match real-time lighting, and enables physical units for light intensity. Instanced albedo and emissives for precomputed lighting We used to allocate the emission and albedo in unique lightmap space for all our lightmaps.
However, since instances generally share the albedo/emission characteristics, we now support generation of those maps per unique instance instead. This reduces the amount of memory that the Progressive Lightmapper uses, enabling you to bake even larger scenes. Additive scene lighting warnings For performance reasons, it is often preferable to split larger scenes into smaller “sub-scenes” that can be loaded or unloaded during runtime depending on visibility. This is known as “additive loading” or a “multi-scene” setup. Additively loaded scenes with global illumination The supported workflow that Unity offers when generating GI lighting for multi-scene configurations allows the user to load all required sub-scenes and then have them generate lighting for this complete scene hierarchy.
The output is a LightingData.asset that stores lightmaps, Precomputed Realtime GI and probe data. This is associated with the first scene that is loaded, which can be inferred to mean the “master” scene. Scenes that are then loaded/unloaded during runtime derive their lighting data from the LightingData.asset associated with the master scene.
In this scenario, the Lighting Settings of the sub-scenes are irrelevant. However, scenes can also be baked individually or loaded in a different order depending on intent.
This can lead to scenes having incompatible Lighting Settings and mismatched lighting data. For example, skyboxes may differ, lightmap resolutions may vary or mixed lighting modes could be different. Previously, Unity did not warn the user of this problem and this has led to some confusion when results were not as expected. Unity now generates a warning to inform the user that there is an incompatibility. Then explicit information about any incompatibilities is provided for easier debugging and validation.
Other improvements We also exposed the “per light” option to the cull lightmapped shadowcasters function (scripting API only), allowing it to be used by the HDRP. Shader Graph (Preview) In 2018.1, we introduced Shader Graph as a Preview package, in order to enable you to build shaders visually. Instead of writing code, you can create and connect nodes in a graph network. Each node in the graph gives instant feedback on the changes, and its ease-of-use means that even new users can be involved in shader creation. For this release, we made several improvements, including: High Definition Render Pipeline (HDRP) support Shader Graph now supports the HDRP with both PBR and Unlit Master nodes. Shaders built with the Shader Graph work with both the LWRP and the HDRP. Vertex position You can now modify vertex position via the Position slot on the PBR and Unlit Master nodes.
By default, the input to this node is object space position. Custom inputs to this slot should specify the absolute local position of a given vertex. Certain nodes (such as Procedural Shapes) are not viable in the vertex shader. Such nodes are incompatible with this slot. Master node settings The settings for master nodes are now available in a small window that you can toggle on and off to change various rendering settings for your shader.
Property reference names and exposed state You can now edit the Reference name for a property, making it far easier to reference your shader properties from script. To do so, select the property and type a new name next to Reference. If you want to reset to the default name, right-click Reference, and select, Reset reference. In the expanded Property window, you can now also toggle the Exposed checkbox. Editable paths for graphs You can now change the path of Shader Graphs and Sub-Graphs. When you change the path of a Shader Graph, this modifies the location it has in the shader selection list.
When you change the path of the Sub-Graph, it will have a different location in the node-creation menu. Is Front Face node With this node, you can change graph output depending on the face sign of a given fragment.
If the current fragment is part of a front face, the node returns True. For a back face, the node returns False. Note: This functionality requires that you have enabled two sided on the Master node.
Gradient nodes This adds gradient functionality via two new nodes. The Sample Gradient node samples a gradient with a given Time parameter. You can define this gradient on the Gradient slot control view. The Gradient Asset node defines a gradient that can be sampled by multiple Sample Gradient nodes using different Time parameters. Texture3D and Texture2D Array This change expands Unity’s support for Texture types via two new property types and four new nodes.
These allow you to define and sample Texture 3D and Texture 2D Array type assets in Shader Graph. Texture 2D LOD node This adds a new node for LOD functionality on a Texture 2D Sample.
Sample Texture 2D LOD uses the same input and output slots as Sample Texture 2D, but also includes an input for level of detail adjustments via a Vector1 slot. Show Generated Code You can now see the generated code for any specific node. To do so, right-click the node and select Show Generated Code. The code snippet will open in the code editor that you have linked to Unity. Vulkan support for Editor on Windows and Linux (experimental) This release includes experimental support for running the Editor on Vulkan for both Windows and Linux.
Vulkan is a new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms. Texture Mipmap Streaming In this release, we have added support for streaming texture mipmaps into memory on demand (i.e.
Only when they are required). What is the benefit? You can enable this feature to reduce the texture memory requirements of a Unity application. How it works When this system is enabled, Unity will only load the higher resolution texture mipmaps when meshes are close to an active camera. The high-resolution mipmap data is kept in memory while the overall texture memory is within a user-defined budget.
If loading a new texture miplevel would cause the texture memory to exceed the budget, then the higher resolution mipmaps, on meshes furthest from the camera, will be freed from memory. Speeds up initial load time The initial scene load time may also speed up due to the reduction in texture data that is first loaded (i.e.
Loading just the lower resolution mipmap levels). The initial load-speed improvements are platform-dependent. More control The Texture Mipmap Streaming system gives you full control over which mipmap levels are actually loaded into memory.
Normally, Unity will load all the mipmap levels that are stored on disk, but with this system, you can take direct control over which mipmap levels are loaded. This system also trades a small amount of CPU time for potentially large GPU memory savings. Simple to enable and manage The feature is simple to enable via Quality Settings, where you can define, per texture, if each should be streamed by the system. You can query the metrics to identify the texture memory usage, while still being able to see the memory savings.
Various settings can also be adjusted to control the system so it balances the memory savings and CPU cost, and to allow you to prioritize some textures over others (e.g. Character textures over environment textures). C# Animation Jobs AnimationPlayables now allow users to write their own C# Playables to interact directly with animation data. Users can also write multithreaded C# code to control the AnimationStream data used by the PlayableGraph, which also allows integration of user-made IK solvers, procedural animation, or even custom mixers into the current animation system. Particle System improvements Here are the improvements in 2018.2: Support for eight UVs This allows you to use more custom data than ever before. MinMaxCurve and MinMaxGradient It’s now possible to use these types in your custom scripts, outside Particle Systems to match the style used by the Particle System UI.
Linear Color Space Particle Systems now converts colors into linear space, when appropriate, before uploading them to the GPU. Emit from Sprites We’ve added two new modes to the Shape module, in order to emit from a sprite or SpriteRenderer component and match particle emission perfectly to the visuals of the sprite. BakeMesh There are two new APIs for baking the geometry of a Particle System into a mesh: BakeMesh bakes the particle geometry, and BakeTrailsMesh bakes the Trails module to a mesh. Show Only Selected (aka Solo Mode) A much-requested feature, this has been made more discoverable and accessible alongside all the other previewing controls on the Scene View Overlay, with the Play/Restart/Stop, etc., controls. ETC Texture Support Shaders that use separate alpha textures can now be used with particles, when you use sprites in the Texture Sheet Animation module.
2D Pixel Perfect Camera (Preview package) Try the Pixel Perfect Preview package to stay true to your pixel art vision. The Pixel Perfect Camera component will help you get perfect, crisp pixels – regardless of the screen size – by making all the calculations automatically for you. Infectonator 3: Apocalypse by Toge Productions Your sprites will even benefit from the feature when they are in motion or rotating, always keeping a sharp pixelation, without having to add interpolation to smoothen the edges as illustrated below. 2D Sprite Renderer “Sort by Pivot Point” Traditionally, the distance between the center of a Sprite Renderer and the axis is used to determine which sprite would be rendered last and therefore appear at the front of the image.
With this release, you can use the pivot point instead of the center of the sprite as the reference point in the various sorting methods, such as arranging by distance to the top of the screen. For example, in top-down RPG games, you need the bottom of the sprite to determine the rendering order of the sprite. The new pivot-point configuration lets you set criteria that better suit your game. 2D Hexagonal Tilemaps You can now build Hexagonal Tilemaps.
This includes support for flat-top and point-top Hexagonal Tiles, which are especially useful for making strategy games or digital board-games. Art courtesy of David Baumgart SVG Importer (Preview package) This feature lets you import Scalable Vector Graphics (SVG) directly into your projects. The SVG Importer allows you to create sprite assets with a very small file size that will retain their quality at any resolution.
The SVG importer supports the most common features of the SVG 1.1 specification, such as gradients, fills, clipping paths, dashed lines, and rounded corners. Vector graphics sprites imported in this manner are supported by the Unity 2D tools. Once an SVG file is imported, the vector data is tessellated into triangles and a sprite is generated. This sprite can then be used by the 2D system. The source for the SVG Importer can be found in the Editor folder of the package. Get the SVG Importer as part of the Vector Graphics Preview package from the Package Manager. The vector graphics APIs can be used to create and manipulate vector constructs directly in code.
The source for the Vector Graphics APIs can be found in the Vector Graphics namespace under the Runtime folder. New 2D APIs You can use the Vector Graphics API to create or manipulate vector data directly in the code. The new 2D Atlas API lets you write custom tools to create or update atlases. For example, you could create personalized character textures using the player’s profile picture, or you could optimize the atlas based on the player’s configuration. Editor – general Support for using.java and.cpp source files as plugins in a Unity project You now have the ability to add.java (as well as.cpp and.a) source files to Unity project plugin folders.
These files will be recognized as Unity plugins and compiled into the APK without requiring the user to build libraries separately in Android Studio. The plugin code remains a part of the Unity project, eliminating the need to create a separate Android Studio project.
Standard Assets replacement We have removed the 5.0 version of standard assets from the Installer in 2018.2 and are working on replacement packages for each part of the former prototyping pack. The first package (Standard Assets: Characters) will be available as a Preview soon after the 2018.2 release. It will contain a First-Person and Third-Person Controller integrated with Cinemachine, as well as a prototyping environment built with Probuilder. For details, watch for a blog post on the subject in the coming weeks. For those of you who need the legacy 5.0 package, it will remain on the Asset store. Unity Hub Unity Hub (v1.0), which will be released soon, is a new tool that was designed to streamline onboarding and setup processes for all users.
It provides a centralized location where you can manage your Unity Projects, and it simplifies how you find, download, and manage your Unity Editor licenses and add-on components. Since our initial release, we’ve been working hard at fixing bugs and fine-tuning the experience. In the past six weeks, we’ve already published more than four releases that have been automatically downloaded and updated on our user’s machines. Here’s a few things that have will ship with Hub 1.0:. Project templates. Custom install location. Added Asset Store packages to new projects.
Modified project build target. Editor: Added components post-installation In case you missed the beta release back in January, you can. Cinematics Camera Physical Properties This release includes new features that make artists and cinematographers feel more confident and in control when working in Unity, including the following:.
A new Physical Camera toggle enables you to reveal settings, which artists and cinematographers will find instantly familiar, like standard Focal Length, Sensor Size, and Lens Shift properties. The Model Importer now preserves the properties of Physical Cameras exported from Autodesk ® Maya ® and other compatible DCCs. Cameras in Unity now perfectly match cameras in other DCCs without the need for additional components or manual FOV calculation.
The Camera component now provides a drop-down of Sensor Sizes for common real-world cameras. Recorder 1.0 Unity Recorder 1.0, which will be released soon, comes with many updates that give users a simple way to manage and record animation clips, videos, and image sequences from the Editor:. New UI: A clean view and easy way for you to manage your recordings. Presets: Save your settings so you don’t need to start from scratch. API: Use scripts to trigger recordings through the API. Multiple recordings: Start several recordings at once, and save them in a list if you need to use the same settings in the future. Record video clips with audio in multiple formats.
Record image sequences in multiple formats. Record and export animations: Export animation clips (via FBX) to your favorite DCC applications. The Unity Recorder v1.0 will be. Core Engine Removal of the old RakNet-based networking feature, our former networking feature, was deprecated in 5.1, and has been removed from Unity 2018.2. That means that any project that uses RakNet will not work with this release. Addressable Asset System (Preview) The Addressable Asset System makes it easier to manage all the things that make up your game, like prefabs, textures, materials, audio clips, animations, and so on. As projects grow, the number of assets increase too.
Users have to reference them intelligently or else everything in your game, from local memory to content distribution, will become difficult to manage. Your content-distribution strategy, in particular, will be harder to manage because asset references are typically resolved at build time, and users often face heavy refactoring in order to make modifications. The new Addressable Asset System makes it easy for your team to scale as your game increases in size. It separates the three primary concerns of runtime asset management: referencing, packaging, and distribution. This simplifies referencing content, whether it’s on the local machine or distributed online via CDN, because the content is automatically loaded and unloaded for better memory management. We also provide profiler tools to further optimize memory usage. Ultimately, this results in faster iteration time for you.
The new Addressable Asset System ships separately. It is available as an add-on via Package Manager and is now in Preview. High-DPI monitor support If you have a 4K monitor, you can now enjoy High-DPI scaling support on both Linux and Windows in the Editor and support for per-monitor display scale factors on Windows.
Deprecation of support for the.NET Scripting backend used by the Universal Windows Platform Since Unity 2018.1, we have been supporting two scripting backends on the Universal Windows Platform (UWP):.NET and IL2CPP. With this release, we are deprecating support for the.NET scripting backend. The goals for this deprecation are twofold.
Easier to port games to UWP The first goal of this deprecation is to make it easier for you to port games to UWP. Much of the developer pain associated with porting games to UWP in the past has been due to differences in API surface area and differences between the.NET Native and the Mono and IL2CPP runtimes Unity uses on other platforms.
This change will ultimately make it easier for most developers to port games to UWP. Helps us offer better support The second reason for this deprecation is to make it easier for us to support you by fixing issues efficiently. Because the.NET scripting backend is completely different from the runtimes we use for all other Unity platforms, it has been challenging for us to maintain a consistent quality-level, relative to the rest of Unity. This deprecation will ultimately enable us to spend less time maintaining the.NET scripting backend, and more time working on the features and issues that are most important to you. IL2CPP has the same.NET API surface as all other Unity platforms,.
So with the addition of the IL2CPP-managed debugger in 2018.2, the developer experience on IL2CPP is now on par with, and superior to, what the.NET scripting backend provides. IL2CPP has been the default since 2017.2, so we expect most users will have no issues with this. However, if you have not yet tried using IL2CPP and you do experience any issues, please be sure to file them. We plan to end backend support for.NET scripting in 2019.1.
C# Job System, Entity Component System and Burst Compiler With our new high-performance multithreaded system introduced in 2018.1, we’re rebuilding the very core foundation of Unity. The new system will enable your games to take full advantage of the multicore processors currently available — without the programming headache. This is possible thanks to the new C# Job System, which gives you a safe and easy sandbox in which to write parallel code. We are also introducing a new model to write performant code by default with the Entity Component System (ECS), and the Burst Compiler to produce highly optimized native code. With great performance by default, not only will you be able to run your games on a wider variety of hardware, you’ll be able to create richer game worlds with more units and more complex simulations. Entity Component System (ECS) In 2018.2, we added several improvements including Reactive system samples. The Reactive system will enable you to respond when there are changes to component state and emulate event-driven behavior.
You can learn more about Reactive systems by watching on the subject. We will also be providing a number of examples and documentation on how to implement Reactive systems using ECS. During the latter half of the year, we will be providing small Unity game samples created by Unity users and converted to ECS by us.
Cio.com Ar Twitter: First Look: Visual Studio For Mac Mac
Burst Compiler With this release, burst compiling for ECS is available on all editor platforms (Windows, Mac, Linux), and you will be able to build AOT for standalone players (Desktop, PS4, Xbox, iOS, Android, and Nintendo Switch). As we progress towards 2018.3, we will continue to focus on ECS performance, release a Preview of determinism, and support more.NET C# language constructions (DllImport, constant arrays, foreach, etc.). We are aiming to bring the Burst Compiler out of Preview in the 2018.3 timeframe.
IL2CPP-Managed Debugger IL2CPP-managed debugging is now available, enabling developers to use their preferred debugger to find and fix errors, even when using the IL2CPP backend. All debugging features will be supported for Visual Studio (with Visual Studio Tools for Unity) and JetBrains Rider on standalone, PlayStation 4, mobile platforms and Xbox One planned for later. Scripting runtime improvements in Unity 2018.2 Unity 2018.2 ships with dozens of bug fixes related to the scripting runtime, thanks to all of the great feedback we have received since the.NET 4.x. ARM64-bit support for Android With this release, ARM64-bit support for Android, based on IL2CPP technology, drops the Preview label.
This version provides you with performance benefits because 64-bit Android apps and your games will be able to address more than 4GB of memory space. APK splitting by architecture You now have the option of splitting the target architecture (x86, ARM 32, ARM 64) into multiple APKs rather than making a large one. Then, for stores that support this option (like Google Play), you’ll only have to download the APK with the relevant architecture. Google Play Instant Games Plugin One of the biggest barriers to acquiring new players is the hassle of the install process. Downloading and opening an app takes time and results in many users giving up before experiencing your game. With, players can try a 10MB instant version of the game without having to install it first. This plugin simplifies the conversion of a Unity-based Android app into an instant app, which can be deployed through Google Play Instant.
The plugin is available as a project on to use with Unity 2017.x and newer versions. The plugin’s features include:. The option to switch between Installed and Instant-build modes. A centralized view of Unity Build Settings and Android Player Settings that need to be changed to support Google Play Instant. The ability to build and run the Instant App on an ADB-connected Android device C# Platform Certificate Store Synchronization We now fully support modern encryption (TLS1.2) across all platforms from.NET 4.x and UnityWebRequest APIs. This includes automatic verification against platform-specific certificate stores. On Xbox One and PS Vita, which don’t provide access to system store validation, an embedded CA store is used for validation.
End of support for UnityScript As previously announced, we have completed the deprecation of UnityScript with this release. From last summer for detailed information. In general, we made this decision because as we continue to upgrade the Scripting Runtime and the version of C# we support, C# will enable greater possibilities:. The Scripting Runtime upgrade enables you to use.NET 4.6 and later C# 7.
The JobSystem makes it possible to easily write multithreaded code in a way that protects you from race conditions and deadlocks. The NativeArray type allows you to create and work with large arrays that have their storage controlled by native code, giving you more control over allocation behavior and eliminating garbage-collection concerns. You have control over the script-compilation pipeline, so you can customize how your scripts are combined into assemblies. We also stopped accepting new Asset Store packages that contain UnityScript code, and we have removed packages with UnityScripts. Finally, we provided a UnityScript-to-C# Automatic Conversion tool. There are a few of these available, but we weren’t happy with the approaches they use. Since we learned a lot about operating on UnityScript code when we wrote the Script Updater, we decided to apply that knowledge and build our own solution.
Visual Studio Code Debugger Extension For those interested in using Visual Studio Code as IDE, we have developed, and we maintain, the, which is available as Preview. For those interested in using VSCode to debug C# code within Unity, please go to this and try it out. We’d love to hear what you think about it.
Note that we are also updating the extension to make it support debugging of C# in the new Mono runtime in Unity and addressing. XR HoloLens Holographic Remoting HoloLens Holographic Remoting allows applications to leverage the power of a local desktop machine to offload rendering and processing at runtime. We think our Automotive and AEC customers will find this feature particularly useful. Release notes The 2018.2 release also includes 183 improvements and 1426 fixes. Be sure to refer to the for the full list of new features, improvements and fixes. We’ll be happy to discuss your feedback on the new features Thanks to everyone who helped test the 2018.2 beta If you were a beta tester, you helped make the release of 2018.2 possible. So thanks for trying out all the new features and providing great feedback.
The 25 Unity Gear Set sweepstake winners We are currently reviewing all the 2018.2 beta sweepstakes entrants and will soon send gift vouchers by email to the 25 winners. (To qualify for a prize, you had to submit a bug entry that had not been previously reported, that we could reproduce, and that we acknowledged was a bug.) Be part of the next beta If you are not already a beta tester, consider becoming one. You’ll get early access to the latest new features and you can test if your project is compatible with the new version. You also get to participate with some of the leading experts in the Unity community, help influence the future of Unity, and get a chance to win cool prizes. You can get access simply.
By joining, you won’t just get access to all the new features, you’ll also be able to help us ensure the highest quality software. As a starting point, have a look at this.
If you would like to receive occasional emails with beta news, updates, and tips & tricks, please sign up below. Is this a release candidate or final version? I cannot believe that it has severe bugs with rigid bodies (already reported and marked as fixed in a future release). These 2018.x versions almost killed our project, I’m stuck with 2018.1b11 since almost all newer releases have this bug. Something critical, kinematic rigid bodies are being affected by the movement of their parent (non kinematic), this should not happen I hope that a fix will come soon, it is hard believing that these Unity releases are stable.
First we got an Android crash with 2018.2, it got fixed soon but it take many hours where we searched for what was causing the issue And the problem was not at our project. And now this severe bug with physics.
These versions should have the beta label guys, please. They are awesome given all the new features, but are far away of something stable or recommended for serious use. I lost more than three entire weeks of work since 2018.1 “stable” came out (so I’m with the 2018.1 beta 11, it has bugs in editor but nothing critical on player). Maybe launching two more stable versions each year could be a better idea instead of three? This would allow more time to beta testing, without suddenly breaking our projects with a final problematic release. Hi there:), If you can provide more info, e.g. What kind of stutter, screenshots of the profiler, exported profiler data and generally more context in a forum post and tag it “performance” or “profiler”, other users and maybe me, if I can find the time, can have a look at it.
With this little information to go on and with having build an runner game for mobile myself before, I’m gonna go out on a limp and assume the typical problem: Allocating data on the heap (showing up in the Profiler as GC.Alloc) costs performance and will eventually trigger GC.Collect since the heap is garbage collected (“managed”) in C#. Garbage collection has quite the performance implications.
There are a lot of mobile games out there, where you can practically see how they are allocating some 40mb of “soon to be garbage” every frame with the typical GC.Collect hiccup every x seconds. This is not really an issue isolated to Unity but within Unity, it is rather easy to ignore or overlook this problem until it’s too late.
Especially with action oriented games, you want your game loop to be running GC.Alloc free. Use the profiler to find where your issues are. See where you can preallocate data or can convert classes (heap data) to structs (stack data) etc. There’s also a bunch of videos on performance optimization in our YouTube channel.
Oooh man, still you’re keeping me in suspense for nested prefabs and automatic tiles (I know I can already download them, but was hoping on the official release just to be safe). But ECS is coming to Whoville, hurray! My game doesn’t need the extra performance, but at the same time why not? I really respect that you’re modernizing your (and our) entire workflow, and slimming down certain features to really give the rest of Unity the attention it deserves.
Though I still can’t get my hands on those juicy nested prefabs, at the same time you’ve given us all these other updates which are, honestly, a bit overwhelming. If you keep this up, UnityHub will soon need dropdowns for each version of Unity to keep browsing through the releases manageable! Great stuff, give Joachim Ante my regards. I try with -force-vulkan and received error in Editor.log file COMMAND LINE ARGUMENTS:./Unity -force-vulkan 0713/003036:ERROR:browsermainloop.cc(161) Running without the SUID sandbox!
See for more information on developing with the sandbox on. Gtk-Message: 00:30:36.044: GtkDialog mapped without a transient parent. This is discouraged. 0713/003036:ERROR:renderermain.cc(227) Running without renderer sandbox 0713/003036:ERROR:sandboxlinux.cc(308) InitializeSandbox called with multiple threads in process gpu-process 0713/003036:ERROR:gpuprocesstransportfactory.cc(402) Failed to establish GPU channel. I will create a thread in forum Linux Editor Thank you!
There is no option inside Unity to increase the font size however Unity will adjust to Windows settings for your monitors. This way you can scale up the font size and the whole Editor UI. Instructions from Microsoft support page: Windows 10 Select Display Change the size of text, apps, and other items, and then adjust the slider for each monitor. Earlier Windows systems Right-click the application, select Properties, select the Compatibility tab, and then select the Disable display scaling on high DPI settings check box. Great update!
Cio.com Ar Twitter First Look Visual Studio For Mac
I love being able to remove built in modules in the package manager. Is there anywhere I can find out more info on what each module covers completely so I know if I’m safe to disable them?
Two examples:. I don’t use the physics or physics2d system except for collider and collider2d components (and their respective raycasters). I assume this means I can’t disable those modules safely, but how would I know that?. I don’t use videos anywhere but I use Unity Ads, do I need to keep the video module? Planar reflections are for the High Definition Render Pipeline. If you grab the latest version of it through the Package Manager, you will be able to add a “Planar Reflection Probe” to your scene (GameObject / Light / Planar Reflection Probe).
Basically, this object is set like a reflection probe and will influence all surfaces within it’s bounds, but will do reflection according it’s relative horizontal plane. Note that you have an example setup if you add a “Mirror” object (GameObject / 3D Object / Mirror), which is a combination of a fully reflective plane + a planar reflection probe.