Release Archive

Unity 3.3

Android Changes from Pre-Release Version

• Native Activity does not support screen orientation changes during runtime.
• Remote refuses to connect to the Editor once the device was disconnected.
• Improvement performance of audio handling (mixing) on Tegra based devices.
• On-screen keyboard has been completely re-written to support NativeActivity, and handle .hideInput=true;.
• Editor detects minimum OS / API version before trying to launch the application.
• AndroidJavaObject et al as proper documentation.
• Added documentation of the AndroidInput class.
• Added correct mapping of CIRCLE button on Xperia Play; must use latest firmware on the device.
• Deprecated WWW.oggVorbis property.
• Remote: Fixed crash in editor caused by editor side of Android Remote.
• Fixed broken detection code for Android SDK API-10 (and API-11).
• Fixed problems with threading and finalizers in AndroidJNI et al.
• Performance improvements of animation skinning on Tegra based devices.
• Support for NativeActivity / SonyEricsson Xperia Play.
• Added support for Screen.SetResolution.
• Fully dynamic linkage to Mono; Mono is now available from plugins etc.
• AndroidManifest.xml attribute minSdkVersion exposed under Player Settings / Other Settings.
• Fixed exception when using AndroidJavaObject.Get().
• Fixed occasional rendering issues on some Qualcomm based devices (e.g. HTC Vision).
• Fixed various network issues (local IP, ping, HavePublicAddress etc).
• Fixed various touch input related issues (Input.multiTouchEnabled, virtual touches, stale touch IDs).
• Added the Windows registry keys for the JDK lookup on x64 machines.

Other Changes

• iPhone and Android Remote is enabled for Unity free license.
• Fixed case 392244: Incorrect handling of tall mode of Game View in Android Remote.
• Fixed case 388824: Android Remote flickering.
• Fixed case 388828: Android Remote crashes due to buffer overflow.
• Fixed case 392869: With Build&Run only remove previous installation when update is not possible (otherwise keep PlayerPrefs etc).
• Fixed case 392194: Fixed AndroidJNI lookup of inner (nested) classes.
• Fixed case 392099: Touch data reset when resuming application ; fixes stale touches after pause.
• Fixed case 392922: Fixed problems when using AndroidJNI and Assembly Stripping.
• Fixed case 392847: Flickering rendering problem (mostly seen on GUI elements) or things not being rendered at all.
• Fixed case 392831: Input.GetMouseButtonDown(0) and TouchPhase.Began being out of sync.
• Fixed case 391064: Changed the message presented to Samsung users when the firmware is outdated.
• Fixed case 391739: Text input is now available in NativeActivity mode.
• iOS: Fixed VAO cleanup (case 392221: memory leak when using GUI.Label).
• iOS: Fixed MSAA+discard support: discard read buffer, not draw; discard stencil too.
• Graphics: Improved performance of fixed-function emulation under GLES2.0.
• Audio: Correct audio CPU usage displayed in the Profiler.
• Audio: Fixed WWW.audioClip (wait for the entire clip to download).
• Fixed case 377132: Fixed rare audio bug where one shots are looping.
• Fixed case 391171: Better handling of orthographic scene view camera.
• Fixed case 383402: Fixed continued bouncing OS X Dock icon when using modal progress bars.
• Fixed case 391471: Fixed editor error messages on Windows with some RenderTexture configurations.
• Network: Fixed error when reading 32 bit network view IDs size.
• Remote: Proper icons for the Android Remote.
• Fixed case 388502: AnimationEvents trigger twice when the event pauses animation then starts it again from coroutine.
• Fixed case 391106: Font security warnings showing up.
• Fixed case 390822: Add implementation for IsDirectoryCreated on iOS.
• Fixed case 388828: Various crash fixes for Android Remote.
• Fixed case 373197: iPhone Remote prints excessively to the editor console.
• Fixed case 388824: Unity Remote white-flickers if you reconnect it to the editor.
• Fixed case 389248: Unity Remote refuses to connect to the Editor once the device was disconnected.
• iOS: Xcode 4 is now recognized as proper build tool.
• iOS: Added soft debugger support.

Unity 3.2

Major Features

• Image Effects: New Depth of Field with bokeh, improved bloom and several other image effect tweaks and fixes.
• New Water: All new Water prefab in standard assets that includes waves, automatically generated foam on shorelines and more.
• Graphics: Major performance improvements in OpenGL ES 2.0 (iOS/Android).
• Shaders: Added optimized/simplified versions of some shaders under "Mobile" category (VertexLit, Bumped Specular, Skybox). They work on other platforms as well, but mobiles will see biggest gains.
• Shaders: Mobile-Optimized Bumped Specular shader is 5.2x faster than Bumped Specular in 3.1 (on iOS)
• Shaders: Added several Unlit shaders that just display a texture with no lighting. They are the fastest textured shaders.
• Debugger: Attaching the script debugger to (and detaching from) Unity and debugging-enabled players is now possible.
• Profiler: you can profile standalone player builds from the Editor. This includes iOS and Android builds!
• Caching: the caching feature is now usable by all content, with or without a special license. Unlicensed content will share a single 50 MB Cache folder.

Editor

Improvements

• Profiler Improvements:
  • Profiler is now able to connect to players to do remote profiling.
  • Added profiler support for iOS runtime. Editor and iOS device should be connected to the WiFi/LAN network.
  • Added profiler stats for physics.
• Assets -> Import Package changed into a submenu for easy access to standard packages.
• Android Remote is now available on all build targets; iPhone remote is now available on all build targets on Mac OS X.
• PlayerSettings script class extended to let Editor scripts control various iOS and Android build settings like stripping, target devices, etc.
• Slide to scrub over AudioClip previews.
• Asset Importing:
  • Direct import of Modo files (*.lxo). Officialy supported Modo versions are 501 and higher.
  • Direct import from Cinema 4D R12.
  • Direct import from Blender 2.55.1 and later.
  • Upgraded FBX SDK to 2011.3.1.
  • Support for import of mesh instances from FBX files. Import of instances is not enabled for direct import of 3dsMax/Maya files due to limitations on FBX exporters (see Known Issues).
• It is now possible to switch the scene view into bottom camera using a three-finger-swipe gesture up from the up camera on Mac OS X.
• When an asset import fails, it will now show up in the project folder, allowing you to reimport it manually if you like.
• Made window zooming using the magnify gesture on Mac OS X less sensitive so it is not accidentally triggered.
• Handles now have Slider2D function for dragging a 3D handle in a plane, see Handles.Slider2D().
• Tree Creator:
  • Improved consistency of the editor's "look" with other Unity editors.
  • "Synced" the Move/Rotate Branch/Leaf tools with the Editor Move/Rotate tools.
  • Cleaned up tooltip text.
  • Model wireframe is hidden when editting branches/leaves.
• Object Picker:
  • Builtin resources have been added e.g the primitive meshes, default-material, default-particle texture etc.
  • Previews of textures now preserve the aspect ratio of the original texture.
• Added check to prevent users from overwriting their project folder when building a webplayer.
• Added API EditorWindow.FocusWindowIfItsOpen.
• There is now an option to show a save confirmation dialog for writing changes to serialized asset and scenes.
• Added build managed dependencies verification step. It will warn when unsupported .NET assemblies get included into build.
• Undo system now has a memory cap to remove undo snapshots that use a lot of memory. This stops unity from crashing when editing big terrains.
• When Unity quits during a script compilation, Unity will now on next restart recompile all scripts. Scripts are now generated automatically from all scripts in the asset database, making it impossible to get scripts into a non-working state if you for example delete Library/MonoManager.asset.
• Heightmap terrain painting is now a lot faster.
• Fixed text overdraw on inspector drop downs.
• ESC cancels search in Scene, Hierarchy & Project Views.
• Made Object Pickers have correct icon in light skin.
• Mac: Dragging out a window to a secondary display now never places it too far up on the screen.
• Changing GUI.skin is 10x faster in the editor and no longer clobbers the GC.
• Dragging assets around inside a filtered Project view no longer moves the asset to root.
• Dragging objects around inside a filtered Hierarchy view no longer unparents the game object.
• Layout dropdown shows name of last selected layout. It's also pre-filled for save layout name.
• Visible layers layermask is persistent between editor sessions.
• Minor Build Settings window tweaks/polish.
• Window docking has been rewritten, it should now have a way better feel.
• EditorWindows now get OnFocus/LostFocus messages when tabs are switched.

Fixes

• Screen.width and Screen.height are now correct when entering playmode using maximizeOnPlay.
• Fixed bug where undo / redo would incorrectly combine multiple undo operations into one step
• Fixed bug where upgrading a project with normal maps would sometimes not mark the texture as a normal map properly in the import settings.
• Fixed bug where, display of 'Texture not yet compressed' was not working.
• Fixed issue where dragging on profiler hierarchy would change the active frame.
• Fixed camera viewport handles incorrect with custom viewport rect.
• Fixed crash when using null texture in Handles.DrawBezier.
• Fixed camera's orthographic state is overriden if camera's inspector is visible.
• Fixed mouse picking in editor issue.
• Fixed crash when instantiating a prefab with Constant Force added in FixedUpdate.
• Fixed no visual indicator when dragging textures onto materials.
• Fixed model preview bitmaps need fixing for models that have an off-center pivot.
• Fixed change to flare setting lost when followed by drag and drop.
• Fixed the Object Picker's 'scene' tab list is empty on initial display for certain object types.
• Fixed warnings in the console for stats window when using networking.
• Fixed dragging material in sceneview does not always update correctly (Only a Windows issue).
• Fixed crash on play when using the Animation system to disable a Mesh Renderer.
• Fixed foldouts eating events when clipped.
• Fixed object fields not pinging when disabled.
• Fixed crash when calling Material.SetPass on a null material.
• Fixed crash when calling NetworkUtility.Ping repeatedly and entering / exiting playmode quickly.
• Fixed 'screencoord[1]' error messages in some situations.
• Fixed tab dragging which could either throw an error "Trying to read pixel out of bounds" or show contents of another window.
• Fixed wrong material previews if Player Settings has VertexLit rendering path.
• Fixed a bug in Mac OS X Editor where assets with unicode characters in their file name would get converted to lower case names.
• Previews in the Object Picker are now correct for dirty assets.
• Fix crash when validating MeshRenderer context menu when there are no materials.
• Fixed broken image references in script reference.
• Fix errors when focusing on terrain with the hierarchy view.
• CustomEditor bug made script-file become unusable in editor.
• MenuItem with negative priorities are now working correctly.
• Fixed texture importer was doing mipmap fade for normal maps wrong.
• Fix sceneview sometimes losing input when a sceneview overlay window was showing (e.g. Camera Preview).
• Fix Build and Run not working in Mac OS X 10.5.
• Windows editor doesn't require MS Runtime libs (9.0) to be installed.
• Fixed rendering issues on Windows with Intel GMA 950/3100 GPUs in Animation, Profiler and Terrain windows.
• Editor Windows stay on-screen in a much more robust fashion.
• Fixed confusing Shader Model 3.0 graphics emulation (it was sometimes disabled on capable GPUs).
• Fixed issue with Static Batching not working after Additive Level Load.
• QuickTime movie importing now works with the latest version (7.6.9).
• Fixed occasional crashes on Windows when closing Asset Store window.
• Fixed Asset Store window minimum size being too large for small screen resolutions.
• Switching graphics emulation properly reloads all textures now (lightmaps could get wrong encoding before in some cases).
• Fixed that ProjectSettings->Editor was only available in pro, while it contained nonpro security emulation settings.
• Fixed inspector enum popups being wrong for fields that have same names but different enum types on same component.
• Fixed crash when using CustomEditor Attribute on a class not derived from Editor.
• MonoBehaviour.Update is now correctly called in batch mode in the editor.
• Fixed bug where prefab instances could lose the prefab overrides on mono behaviours when new properties were added in some corner case scenarios.
• Fixed clicking behaviour while renaming in Hierarchy & Project View (sometimes Unity would not apply the new name).
• Fixed context menus not working in various Project Settings inspectors.
• Fixed imposter camera showing in the hierarchy for a single frame after creation.
• Fixed Tree Creator mesh not updating properly when editing value's directly in a text field.
• Fixed creating projects through command line using relative paths on windows.
• When selecting font with unsupported format in inspector, display nice error box instead of crashing.
• Control/Command + click in SceneView now selects game objects as well as deselects them.
• Fixed: Don't open hierarchy window for no good reason when creating e.g. Cube game object.
• Remove Components -> Miscellaneous -> Tree menu item, as it does not do anything useful.
• Fixed display of unicode characters in the layouts popup menu.
• Mac Editor: Popup windows no longer gets sent to back when you close another popup window.
• Fixed layout label issues with Vector Fields.
• Dragging out windows no longer can leave a 1px white hairline on bottom and right edges.
• Dragging while zoomed in on mac no longer renders the window unresizable.
• Fix gear context icon for material and texture inspectors in dark skin.
• Build settings properly reflect changes to moving(renaming) scenes.

Graphics

Improvements

• Major performance improvements in OpenGL ES 2.0 (iOS / Android):
  • Much improved performance of shaders that are compiled from Cg/HLSL (e.g. Diffuse for directional light is about 2x faster on iPhone 3Gs). Now fixed/half/float types in Cg map to lowp/mediump/highp precision in GLSL. Use lowest precision type in your shaders!
  • Improved GLSL shader optimizer.
  • Changed normal map compression approach for mobile platforms. It's much faster now!
• Fog mode can be changed in Render Settings (also from scripts): Linear, Exp, Exp2 (default).
• Rendering performance optimizations (lower CPU overhead, less memory consumption).
• Shadows:
  • Forward rendering path supports Point & Spot light shadows again, as well as multiple shadowing lights! Note that by default shaders do not have this enabled, use fullforwardshadows surface shader directive to enable the behavior.
  • Directional Light soft shadows blur width and fadeout speed can be adjusted in Inspector or via script.
  • Exposed Light.shadowBias to scripting.
• Built-in shaders that perform Deferred Lighting, directional light shadow gathering in Deferred Lighting, and directional light shadow blurring can be overriden. Just drop your own shaders with the same names into the project.
• Deferred light buffer can be accessed from from Image Effects or other shaders (_LightBuffer).
• Surface Shader improvements:
  • support world-space normal as input (worldNormal).
  • fullforwardshadows directive to enable all shadows from any lights in forward rendering loop.
  • dualforward directive to enable dual lightmaps in Forward rendering.
  • decal:blend mode for shaders used on decal-like surfaces.
  • nolightmap directive to exclude lightmap support (makes shaders smaller).
  • noambient directive to not apply ambient nor SH lighting.
  • halfasview directive to compute normalized half-direction per-vertex, and pass that to the lighting function. Results in faster Specular-type shaders, however view direction won't be entirely correct.
  • approxview directive to compute normalized view direction per-vertex instead of per-pixel. Results in faster Specular-type shaders, however view direction won't be entirely correct when camera gets close to surface.
  • noforwardadd directive to skip generating forward additive pass. Will make a shader support one full directional light; all other lights will be per-vertex/SH.
• Shaders: #pragma glsl_no_auto_normalization directive to not auto-normalize normals & tangents in OpenGL ES 2.0 shaders.
• Shaders: Added TransformViewToProjection to do this properly on mobile devices with regard to orientation (on non-mobile it will be usual multiplication by diagonal terms of projection matrix).
• Shaders: Added per vertex lit tree shaders previously used in the Bootcamp demo. To be used with Tree Creator trees and located in "Nature/Tree Creator Leaves Fast".
• Desktop GLSL shaders now allow OpenGL ES precision types to be used.
• Added GL.GetGPUProjectionMatrix that returns actual projection matrix that will be used in shaders.
• Added support for 16bit RenderTextures.
• Scaled meshes are now only recreated if the scale has actually changed. This improves performance hiccups on same games.
• Texture2D.GetPixel and friends work on RGBA32 textures (common case for uncompressed textures on mobile platforms) in addition to ARGB32 ones.
• Texture2D.Apply and Texture2D.PackTextures now have additional parameter makeNoLongerReadable (default to false) that will mark Texture as not Readable, and free up system memory after uploading to GPU.

Fixes

• Shaders: Bunch of fixes to Cg->GLSL shader translator:
  • Translates 'half' and 'fixed' matrix types properly (previously 'half' was translated to high precision, and 'fixed' was not supported).
  • Support lit() built-in function.
  • Fixes to swizzles on floats.
  • Support static qualifier.
  • Better handling of 2D matrix indexing, e.g. matrix[i][j].
• Shaders: fixed mis-compilation of matrix constructors & matrix indexing when translating shaders to GLSL.
• Shaders: fixed mis-compilation of modf() and fmod() when translating shaders to GLSL.
• Shaders: Postprocess Direct3D pixel shaders that come close to 64 instruction limit to work around a crash on Intel GMA 950.
• Shaders: Fix some bogus error messages when loading Direct3D shaders.
• Surface Shaders: in case of syntax errors, proper line numbers are reported now... how cool is that? ;)
• Surface Shaders: support #pragma multi_compile directives properly.
• Lightmapper fixes:
  • Fixed UV layer creation for Beast. Fixes all the "Duplicate uv layer name" errors.
  • Fixed tiling and offset being ignored for _MainTex on objects using a non-white color.
  • Fixed an issue in Beast causing black areas surrounded by white outlines to sometimes appear in lightmaps.
  • Fixed lightmapping of objects with mirrored (odd-negative) scale.
  • Fixed the crash when lightmapping terrains where the Terrain script references a missing TerrainData asset.
  • Fixed an issue with Beast occasionally cancelling the bake process (especially on Mac OS X, but also causing poor performance on Win) when using a lot of memory.
  • Fixed the issue with 4096 size terrain lightmaps not baking on Mac OS X.
• Fixed DXT5 alpha channel decompression to better match what GPUs are actually doing.
• Fixed Texture2D.GetPixel on Alpha8 format returning 0.00392 in RGB channels instead of 1.0.
• Fixed a bug in Cloth rendering that was mostly happening on Windows with Radeon GPUs.
• Fixed custom projection matrices sometimes not working properly.
• Fixed inconsistent triangle count display in Game View Stats when dynamic batching is used.
• Fixed creation of compressed textures at runtime.
• Fixed validation of vertex/pixel shaders that use more textures than the GPU can handle.
• Fix texture scale/offset not being applied when writing shaders in GLSL for desktop platforms.
• Fixed editor fonts getting corrupted once RenderTextures are used on Mac OS X 10.5.x with Intel GMA 950 GPU.
• Fixed Texture2D.ReadPixels on Direct3D when reading into a portion of a texture.
• Fixed Soft Occlusion Tree shaders sometimes rendering overbright on Windows with GeForce FX/6/7 GPUs.
• Fixed lightmapped VertexLit shader applying fog in a wrong way on old GPUs with only 1 texture unit.
• Texture2D.ReadPixels properly reads from Game View when non-full aspect ratio is used.
• RenderTexture.GetTemporary now always returns a texture with bilinear filtering set (previously could return with something else when returning a texture from existing texture pool).
• Fixed directional light shadows in case of weird projection matrices (e.g. Refractive Water).
• Make WindZones be properly affected by Time Scale.
• WindZones properly affect Tree Creator trees put into terrains now.
• Fixed wrong Point/Spot light attenuation on Tree Creator leaves.
• Graphics.Blit does not require using Cull Off in the shader now.
• Shadows can be properly cast from particles now, if you use opaque or cutout shaders on them.
• Fixed changing Flare color from script not always having effect.
• Opaque objects are front-to-back sorted again for performance reasons. Looks like this got lost with all batching work in Unity 3.0.
• Fixed dynamic batching issues with uniformly scaled objects and vertex lighting on Direct3D.
• Fixed rendering of scenes containing objects with odd-negative scale in deferred when any of the lights was casting shadows.
• Fixed Deferred Lighting not respecting camera's Don't Clear mode.
• Fixed bogus error message when a shader with an empty name has no fallback.
• Fixed half-texel offset error when generating tree creator texture atlas.
• OpenGL ES 2.0: Fixed Fog with semitransparent fixed function shaders.

Unity iOS

To top

Improvements

• Alpha-tested objects are drawn after fully opaque ones for performance reasons.
• Implemented MSAA (Multisample anti-aliasing) support. You choose it in Quality Settings just like for other platforms.
• Audio: Gapless looping of MP3s! Unity's MP3 encoding is completely rewritten and silent frames and/or audible "pops" around the loop point is no more. Use the "Gapless loop" option in the Audio Importer to encode the MP3 for looping. Beware this stretches/resamples the sound which theoretically can affect quality.
• Mobile devices now have their own quality settings (Project Settings->Quality->Default Mobile Quality).
• Improved performance by using OES_vertex_array_object and EXT_discard_framebuffer extensions.
• Added automated native plugin integration into Xcode project. All .m/.mm/.c/.cpp/.a files located in Assets/Plugins/iOS will be merged into Xcode project with every Unity project build.
• Performance warning now shows up when deploying a project using anti-aliasing and/or more than 1 pixel light.
• Use unnamed process-wide kernel semaphores instead of slower system-wide semaphores.
• Added armv7 only target platform.
• Added "latest" SDK option, should work only for 4.2 and later SDK.

Fixes

• AOT compiler stability improved when generics are used with value types like Vector3.
• Audio: Restore AudioSession without losing any state (audio will continue just where it was interrupted).
• Audio: Fix audio stopping when releasing a source referencing an audio clip that is in use. This resolves audio stopping when loading a new scene.
• Fixed SystemInfo.operatingSystem.
• Fixed Toon Outline shaders not working on iOS with landscape orientation (update Toon Shading package).
• Fixed audio not coming back after an app switch on iOS.
• Fixed simulator support.
• Fixed -all_load linker option support.
• Fixed GUI slider + stripping problem.
• Fixed problem when editor was stuck in Xcode project append mode.
• Fixed animation curve stripping problem.
• Fixed UnityScript and Boo Array support.
• Fixed MonoProperty.GetValue for .NET 2.0 Subset profile. For full .NET 2.0 profile this feature is not supported.
• Fixed freeing up audio assets after loading audio into FMOD.
• Now editor will report location service as stopped instead of running.
• Audio: Fixed www.audioClip streaming.
• Improved micro mscorlib compatibility with stripping.

Unity Android

To top

Improvements

• Upgraded to Android OS 2.3 (Gingerbread); Editor needs the latest SDK.
• Android Remote - Remote debugging tool for Android devices.
• The script debugger is now enabled for Android players.
• Added proper development build player, with support for profiling / debugging.
• Proper device filter for devices equipped with an ARMv6 (VFP enabled) CPU.
• Support for reversed landscape / portrait up-side-down screen orientation (Gingerbread and later only).
• Support for extra large screens, ie tablet devices (Gingerbread and later only).
• Implemented Location Service (GPS/Wifi).
• Decreased the install size to the Internal Storage flash memory (currently approx. 180KB, ie ~2% of 3.1).
• Audio: Gapless looping of MP3s! Unity's MP3 encoding is completely rewritten and silent frames and/or audible "pops" around the loop point is no more. Use the "Gapless loop" option in the Audio Importer to encode the MP3 for looping. Beware this stretches/resamples the sound which theoretically can affect quality.
• First draft of typeless JNI integration from scripts (C#/JS) through AndroidJavaObject / AndroidJavaClass and AndroidJNI / AndroidJNIHelper.
• Added UnitySendMessage on Java side to provide callback functionality to C# / JavaScript.
• WWW now uses system URL class; https://, and also jar:, is now supported.
• Added Application.persistentDataPath and Application.temporaryCachePath.
• Added PlayerSettings / Other Settings / Force SD-Card Permission.
• Removed all Unity specific resources from /res/ folder; this will ease the integration of Java resources in Plugins.
• LVL permissions are detected by usage, rather than whether PlayerSettings / LVL Public Key is filled in.
• Input.inputString now also works with hardware keyboard on the devices which have one.
• Added editor preference for Android SDK location.
• Now have their own quality settings (Project Settings->Quality->Default Mobile Quality).
• Performance warning now shows up when deploying a project using anti-aliasing and/or more than 1 pixel light.

Fixes

• Fixed the tablet accelerometer bug where portrait/landscape axis were swapped.
• Fixed NullPointerException race-condition in FMOD when pausing the application.
• Behaviour of 'Compress Assets on Import' turned off is now that no textures or assets will be reimported with their platform specific override settings right away. Thus allowing for fast switching between build targets. When a build is made, all assets are ensured to have the right format. (was done in earlier builds actually).
• JDK lookup now fallbacks to use the PATH if registry key is not found / valid (Windows).
• Fixed: No more duplicate entries in AndroidManifest.xml.
• Fixed the clip rectangle of the soft input text box not being updated properly.
• Added missing Mono machine.config specification file (needed for SQL access).
• Audio/Accelerometer disabled in QCAR application due to missing onResume() call.
• Audio: Fixed www.audioClip streaming.
• Fixed crash when the LVL key is invalid.
• Fixed touch began events to always have zero Touch.deltaPos.
• When tapping faster than once per frame, individual taps are no longer lost, they're reported as taps with a separate finger ID and properly incremented tap count.
• Touch.tapCount is no longer hardcoded as 1 and properly returns number of rapid taps in nearly same position.
• Timestamps no longer lose data by squeezing 64-bit values through 32-bit parameters.

Audio

To top

Improvements

• FMOD 4.32.02 used across all platform/build targets.
• Fallback on FMODs software mp3 decoder when Apple's decoder (hw/soft) fails completely.
• Better documentation for min-/max-distance properties.
• .Play() with a delay now works on iPhone.
• Streaming with WWW.audioClip now works with OggVorbis (PC/Mac/Web), MP3 (iOS/Android), WAVs (all platforms) and module files (all platforms).
• Streaming with WWW.audioClip is much faster.
• Stream audio from disc. Added "Stream from disc" option in the Audio Importer. Choose this to stream audio directly from disc instead of loading the entire clip into memory. This can decrease your application memory usage greatly.
• Optimize the playback of compressed audio (on Android and iOS).

Fixes

• AudioImporter inspector cleaned up and simplified.
• Fix sounds starting when switching back to a paused editor on Windows.
• Fix memory trash when encoding 8 bit wav files to MP3.
• Never re-encode already encoded/compressed audio.
• You can now set labels on Audio Clips.
• Reverb zone's position can now be changed runtime.
• Optimized play back of uncompressed audio (wav/aiff) files with "Compressed in memory" flag checked.
• Fixed min/max curve editor drawing when min/max-distance is set from script.
• Fix audio inspector showing garbage for audio assets that failed to import.
• Force To Mono checkbox disabled for already encoded files. It had no effect anyway.
• Meta files on older audio assets not changed when upgrading.

Physics

To top

Improvements

• Tweaked Continuous Collision Detection to behave better, with objects coming to rest properly.
• Allow access to cloth simulation vertices by exposing Cloth.vertices and Cloth.normals.
• Added Rigidbody.constraints to allow constraining Rigidbody rotation and movement to specific axes.

Fixes

• Changing the trigger flag of a collider at runtime will now also be respected by Raycasts.
• OnCollisionExit messages now work when the colliders are moved apart from scripting.
• Fixed SkinnedCloth crashing Unity on player resolution change.
• Fixed a crash in PhysX which could occasionally occur when modifying or destroying a collider during a CCD collision.
• Parenting a collider to a rigidbody at runtime will now correctly add it to the rigidbody.
• Fixed a crash when destroying or deactivating a collider in OnControllerColliderHit.
• Fixed editing Character Controller propteries in play mode.
• Make SphereCollider vs. TerrainCollider collisions smoother.
• Fixed a crash in PhysX when trying to use some oddly-shaped meshes as convex MeshColliders.
• Fixed a crash when trying to set properties on an invalid SpringJoint.
• Fixed wrong prototype for OnCollision* messages causing classID errors.
• Fixed setting MeshCollider properties from the inspector at runtime and a related editor crash.
• Collider.bounds will now return an exact bounding box for rotated capsule and sphere colliders.

Other Improvements

To top

• JavaScript Improvements:
  • Multidimensional arrays: int[,]
  • do-while statements.
  • final/static/internal class modifiers.
  • Support for nested classes, enums and interfaces.
  • Assembly level attributes: @assembly SomeAttribute()
  • Parameter attributes: function foo(@SomeAttribute bar)
  • Support for turning off specific pragmas on a per module basis: #pragma strict off
• MonoDevelop: Improved code completion for JavaScript and Boo, especially on Windows.
• Scripting Improvements:
  • Added OnDestroy function that is called before any MonoBehaviour will be destroyed.
  • Added AssetDatabase.ExportPackage and AssetDatabase.ImportPackage.
  • Using AddComponent(Type t) now works for components that come from dynamically loaded assemblies at runtime.
  • Added MovieTexture.duration.
  • Added Mathf.IsPowerOfTwo and NextPowerOfTwo.
  • Object.ToString will now return the object's type and name.
  • Updated Boo to 0.9.4.9 version.
• Increased reliability of destruction functions. OnDestroy and OnDisable will be called on the game object before any modifications to the game object hierarchy have occurred. Destroying of objects is now faster.
• Networking: It's now possible to remove Network.Instantiate calls from the RPC buffer by calling Network.RemoveRPCs on the first NetworkView in the instantiated object.
• Caching: the caching feature is now usable by all content, with or without a special license. Unlicensed content will share a single 50 MB Cache folder.
• Standalone builds: Added an option to disable writing of log files, because Apple may otherwise reject Mac App Store applications in some cases.
• Standalone builds: Added watermark when running Development builds, to avoid shipping with profiling/debugging turned on.
• Asset Server: explain to user why some of the selected assets in merge window cannot be merged.

Other Fixes

To top

• Fixed a potential crash when stopping a streaming movie texture while it is downloading.
• Generated materials during import now have correct capitalization.
• Exposed texture settings in TextureImporter class.
• Fixed deadlock in some corner cases in the Instantiate function, while loading asynchronously.
• Left handed mouse buttons are now correctly recognized on Windows.
• Standalone Player: Fixed instability/crash when running the Windows player in batchmode.
• Mac OS X Standalone: Fixed default folder access mode setup to be allowed onto the Mac App Store.
• OnApplicationPause is always invoked.
• Fixed "thread_stack_pcs" and "~/.wapi" Mac App Store submission problems.
• Destroying a transform component is now forbidden and an error message is displaying telling the user to destroy the game object instead.
• Fixed crash when passing a generic type as argument to Resources.FindObjectsOfTypeAll.
• Fixed crash when passing a generic type as argument to GetComponent.
• Fixed: javascript shortcircuited boolean operations that involved implicit boolean casts of operands were not short circuiting.
• Fixed: javascript support for calling methods taking a variable number of arguments with an explicit array argument.
• Application.LoadLevel will not destroy scene assets if they are still in use by a game object marked as DontDestroyOnLoad.
• Fixed Copy, Paste and other keyboard commands in Mac OS X Standalone.
• Fixed Input.mousePosition while typing in Mac OS X Standalone.
• Fixed installation of Unity Web Plugin from Dashboard widgets.
• Caching: Added Caching.IsVersionCached as replacement for the deprecated GetVersionFromCache.
• Fixed setting the font of a TextMesh from a script (the mesh would not update previously).
• Fixed a crash when creating Behaviour-derived built-in components during a FixedUpdate() call.
• Web Player Fixes:
  • Java Applet Installer: Use custom logo and progress bar/frame like in regular web plugin.
  • Fixed issue with loading Meshes built with older version of Unity.
  • Mouse movement is properly recognized on Google Chrome.
  • Internet Explorer now recognizes Tab key.
  • Background, border and text colors are properly displayed when installing Web Player.
  • Google Chrome doesn't crash when web page is refreshed multiple times in succession.
  • Internet Explorer doesn't crash during Web Player installation when legacy Java version is installed.
  • Fix crash when webplayer encounters .NET code it thinks is illegal. VerificationException is now thrown instead.
  • WWW.LoadUnityWeb will now work with streamed .unity3d files.
  • Allow passing strings with line breaks ('\n') to Application.ExternalCall.
  • Mac: Fixed Copy&amd;Paste (and other Cmd-key equivalents).
  • Mac: Fixed a problem where the player could fail to update the screen in Chrome.
  • Mac: Fix an occasional plugin failure when trying to load Unity 2.x content.
  • Mac: Make cursor hiding in Google Chrome and Firefox 4 work reliably.
  • Mac: Fix focus issue in Firefox 4.
  • Mac: Fix crash when unloading plugin in Firefox 4.
  • Mac: Fix normal PowerPC webplayer behaving like development webplayer.
• Animation Fixes:
  • Animations were not sampling last keyframe in Clamp and DefaultWrapMode modes.
  • Animations were not stopping properly when animation speed is negative.
  • Unity uses much less memory when importing split animations now.
  • Fixed leak when animation system sampled material at out of bounds material index.
  • ModelImporter inspector doesn't allow to enter 0 frame split animations and ModelImporter gives error if it finds such animations.
  • When imported model has has multiple roots and animation doesn't Unity will add an extra root to animation in order to unify hierarchies.
• Fixed import of textures/materials from old MotionBuilder files.
• Fixed Materials are not imported from all layers (fixes Fbx2010.2 imports from Cinema4D).
• Fixed 3ds import crash when special characters are used in texture paths or material name.
• Implemented detection and warning when Scale Compensation is used in FBX file.
• Implemented detection and warning for FBX files which have keyframes at invalid times (before -100 hours).
• Fixed FrameRate import from FBX 2011 plugins - previously it used to always have 30FPS when imported from FBX 2011 plugins (i.e. Maya 2011, 3dsMax 2011 and so on).
• AssetServer: Fixed case where merging a conflicted file would result in a file with its last content chopped off.
• Security: Remove excessive logging from socket and www security.
• Security: Security check now accepts URL extensions using upper case chars.
• VisualStudio/MonoDevelop integration: ignore warning about private methods not being used, since Unity users need to use that construct a lot.
• MonoDevelop: Workaround network failures when detecting local editors on Mac OS X.
• MonoDevelop: Incorporate improvements from MonoDevelop 2.4.2.
• Mono: Merged fix for generics constraint validation.
• Mono: Fixed yield when waiting for multiple coroutines.
• Mono: Fixed crash when Starting empty coroutine.
• MonoDevelop: Merged fixes from stable 2.4 branch.
• Networking: message type 73 is now properly processed as a NAT punchthrough failed connection attempt.
• Networking: Fixed proxy server issues when using Network.useProxy.
• Networking: Fixed problem with using NAT punchthrough in the Editor, it didn't work after the first time and unknown message ID errors popped up.
• Networking: Fixed problem with NAT punchthrough on Windows machines related to network GUID overflows.
• Networking: Fixed problem with NAT detection where Port Restricted was sometimes reported instead of Address Restricted or Full Cone.
• Fixed using layers and multiple animation per layer could result in incorrect blend.
• Fixed ImportNormals mode None (on FBXImporter) didn't work it used to do the same as Calculate mode and give and an incorrect warning.
• Removed/Cleaned up small leaks in WWW class.

Changes

To top

• Editor: iOS SDKs prior 4.x were removed from SDK list. New default is iOS SDK 4.2.
• Implemented 3 minute timeout for import of Maya files.
• Implemented detection, fix-up and a warning message for NANs in animation curves of FBX files.
• Default Sync to VBL to 'true' in Good, Beautiful, and Fantastic Quality Settings.
• Proper errors when there is another project's library folder in the project.
• Application.dataPath will work like in the web player, returning the URL of the folder containing the .unity3d file (previously it would just crash).
• WindZones do not "ramp up" over time anymore.

Known Issues

To top

• When autoconnect profiler is enabled the Editor can become unresponsive after selecting Build and run for Android.
• Direct Modo file import issues:
  • Files can not be imported from modo 401, due to a problem in Modo batch mode.
  • UV coordinates for some meshes are not imported correctly, due to a problem in Modo Collada plugin.
  • Normals for some meshes are always exported as hard edges, due to a problem in Modo Collada plugin.
• Unwrap: some implementation details were changed, so you may need to rebake your lightmaps, due to UV changes.
• 3dsMax reference meshes are not imported correctly (FBX plugins do no export any modifications added on top of the instance), because of the bug on Autodesk side. No changes on Unity side are needed, so it will be fixed as soon as Autodesk fixes FBX plugin for 3dsMax.
• Materials on instance meshes are not imported correctly - they always share the same material. This happens due to structure of FBX files, so this can't be fixed until Autodesk makes FBX structures more suitable for instanced meshes with different materials.
• When duplicating a dirty asset its preview in the Object Picker is incorrect until dirty again.

Unity 3.1

Fixes added by the 3.1.0f4 hotfix release

Unity 3.1.0f4 is a hotfix release to the Unity 3.1 release (version number 3.1.0f3).
Unity 3.1.0f4 was released November 29th 2010.

Fixes:

• Mac Web Plugin: Fixed an incompatibility with a recent version of QuickTime, which caused the web player to stop working on some machines.
• Win Web Plugin: Fix the bug where Firefox hogs all CPU resources when Web Player tab is inactive.
• Editor: Fixed a crash bug when using Undo after closing the Asset Store.
• Mac Editor: Fixed an Asset Store crash bug on some machines with an incompatible version of WebKit.
• Fix for broken tree billboard transitions.

 

Additional Improvements & Fixes in 3.1.0f3

As usual, we added a couple of improvements and fixed some things.
Unity 3.1.0f3 was released November 10th 2010.

New Features:

• Managed .NET DLLs can now be placed in the project folder and can contain script code, including MonoBehaviours, EditorWindows and ScriptableObjects. This allows you to move any code into a DLL, making code sharing between projects easier, and making it easier for middleware developers to create libraries without sharing the source code. This was introduced in Unity 3.0 but was not mentioned in the release notes.
• Scripting: Added GL.InvalidateState() to flush the internal renderstate cache in Unity. This is mostly useful when writing native code plugins that access the 3D device.
• Audio: Added AudioSettings.outputSampleRate. Returns the mixer's output rate; use this to calculate the precise hertz range returned from GetSpectrumData().

Fixes:

• Editor: Fixed out of memory errors when editing very large terrains due to the Undo system.
• Editor: Fixed "too many open files" error when reimporting a large project with many shaders on Mac OS X.
• Editor: Some textures would not say "Texture not yet compressed" when importing with the "Compress Textures" preference turned off.
• Editor: Fixed a bug where upgrading a Unity 2.x project with normal maps would leave some normal maps not marked as Normalmap type properly.
• Terrain Engine: Unity 2.x Soft Vegetation tree shaders had lighting upside down :)
• Shaders: fixed Surface Shader compilation errors with large custom output structures.
• Shaders: wrong syntax in UnityCG.glslinc file (for GLSL shaders).
• Graphics: fixed Projector crash in some circumstances.
• Graphics: fixed tangent vectors not bound correctly with GLSL shaders on some GPUs.
• Graphics: fixed dynamic batching corrupting vertex colors on Direct3D.
• Graphics: fixed GL.TRIANGLES rendering with large triangle counts on Direct3D.
• Graphics: fixed some hiccups when changing non-uniform scale of meshes.
• Graphics: Fixed dynamic batching index overflow.
• Audio: GetOutputData/GetSpectrumData API changed so it accepts an pre-allocated array instead of allocating on every call. Old API is deprecated and marked obsolete.

Unity iOS Fixes:

• Fixed render texture support on iPad with OS 3.2.
• Fixed video autorotation. Pinch zoom gesture now disabled during video playback.
• Fixed stripping of GUI scrollable area.
• Fixed OpenGL ES 1.1 cache invalidation, which was sometimes causing visual artifacts.
• Fixed render texture memory leak.

Unity Android Improvements & Fixes:

• Plugins folder is moved; it now uses Assets/Plugins/Android to scan for plugins.
• Plugins now support standard Android project layout; /assets, /bin, /libs and /res will be merged with the final package.
• Added 'update necessary' notifcation dialog for Samsung devices running pre-2.2 OS firmware.
• License Verification Library (LVL) no longer causes a crash.
• Added iPhoneUtils.isApplicationGenuineAvailable() to be able to determine if application integrity can be confirmed or not.
• Ignore .meta files (with external version control) when packaging the .apk.
• Assign DefaultImporter to platform specific plugin assets.
• Custom manifests are now merged with the properties from the editor (like Bundle Identifier, Version and permission flags).
• Ship UnityPlayerActivity as source code template for writing plugins with custom activity classes.
• Added support for translucent (RGBA 8888) rendering surface.
• com/unity3d/player/UnityPlayerActivity.currentActivity field is now found at com/unity3d/player/UnityPlayer.currentActivity.
• iPhoneKeyboard is now displayed on top of the application; it supports the basic soft keyboard layouts (URL, Email, Phone, etc).
• PlayMovie is now displayed on top of the application (instead of in a separate activity); fixes the screenCanDarken issue while playing movies.
• The editor now checks for device specifications before trying to deploy in Build&Run.
• The editor will try to locate the JDK based on information stored in the registry on Windows.
• Fixed C# assemblies being loaded from the wrong thread; was causing crashes if external classes were loaded late at runtime.
• Fixed render textures on OpenGL ES 2.0.

Unity 3.0

Additional Features & Improvements

As always, we've added a slew of other features and optimizations... keep reading for too much detail.

Android Support:

• Support for Android OS is added in this version.
• Please note that this an early build and does not represent the final Unity Android quality.

Standard Assets:

• Standard packages split into more specialized and smaller packages.
• New Image Effects: Sun Shafts (aka God Rays); Bloom & Lens Flares; Vignetting & Chromatic Aberration; Curve based Color Correction; Depth of Field; Contrast Enhance (aka Unsharp Mask); Geometry Outline; Fisheye; Create Shading.
• Improved particle effects.
• New Skyboxes with alpha channels to be compatible with Image Effects.
• New Editor Scripts for useful shortcuts that are not built-in.
• Improved First Person Controller that uses Character Motor script.
• New CharacterMotor script for use with CharacterControllers.
  • Proper movement on slopes and steps without loosing grounding.
  • Support for standing on moving platforms with multiple movement transfer modes when jumping off.
  • Variable height jumping and other jump improvements.
  • Improved speed and acceleration control.
  • Customizable sliding and perpendicular jumping can prevent climbing up too steep surfaces.
  • Detached from input so it can be used for first person, third person, AI, etc.

New Editor Features:

• Black is the new 50% gray. Unity Pro got a new look - you can toggle it in the preferences.
• Procedural Tree Creator. Documentation.
• Integrated Lightmapping via Illuminate Labs' Beast. Documentation.
  • Automatic generation of lightmap UVs (mesh import setting).
  • Terrains use the same solution and gain a whole new look when used with skylight.
  • You no longer use special "Lightmapped" shaders; all shaders that interact with lighting can handle lightmaps. Dynamic shadows from characters mix with lightmaps properly.
• Object Selector. We no long show a simple dropdown menu; instead a swanky new window opens up, with previews and everything.
• Scene View improvements (documentation):
  • Search field with interactive highlighting of objects.
  • Rectangle selection.
  • Vertex Snapping for precise object placement.
  • Live previews of material, prefab and texture drags into the scene view.
  • Improved camera handles, and a camera preview window.
  • Improved light handles.
  • More consistent scene navigation controls.
• New texture Import Settings dialog with simpler interface & per-platform import settings.
• New Build Settings window to better support multiple platforms.
• New and more organized platform-aware Player Settings Inspector.
• Curve Popup Window:
  • Any public script variable of type AnimationCurve is now exposed in the Inspector as a curve field.
  • Clicking a curve field opens a popup window with a curve editor, similar to the curve editor in the Animation Window.
  • Customizable curve fields can also be used in custom editor windows.
• Editor checks when new versions are available< and notifies the user.
• Texture compression is now multi-threaded for faster texture imports on multi-core computers.
• Asset Server Window:
  • History window shows multiline commit descriptions directly in the list instead of tooltips.
  • Selected history window items are revealed better.
  • Framing (F key) works for history window file list.
  • Remember user/password per host name.
  • Disable merge button in conflict resolution window for non-merge-able items.
• Improved error reporting for shaders. Shader Inspector also displays the list of errors & warnings for selected shader.
• Implemented snap to grid in Curve Popup Window and Animation View when holding down Control (Command on OS X). Control/Command no longer adds to selection, but Shift can still be used for that.
• Editor Console displays total number of errors & warnings in lower right corner.
• Improved inspector for movie audio.
• Windows: Double-clicking *.unitypackage will open and import it.
• Editor API has been expanded: documentation.
• Added option to search for object types instead of names in the project search field.
• Can now drag objects onto an array field in the inspector to add them to the array.
• Can now drag project folders onto the Project Wizard on Mac OS X to select them.
• Nicer display of thumbnails when dragging tabbed editor windows.
• Long operations show progress badge on the Unity Dock icon in Mac OS X and on the taskbar button in Windows 7.
• Added support for touchpad gestures in OS X editor, for maximizing windows (pinch gesture), and switching camera in scene view (swipe gesture).
• Overdraw visualization mode does not do alpha testing now. Alpha tested pixels still cost on the GPU, so better to visualize the real cost.
• Animation window can display animation clips from prefab, just click the prefab's root game object.
• Protect Transform position, rotation, scale against invalid values.
• Build Pipeline: Typetrees are removed from serialized files (assets) when possible, this make resource files smaller and loading time faster.
• Double-clicking a Game Object in Hierarchy View will frame select it in Scene View.
• When going out of Play mode and the Game View is docked together with other tabs, go to last active tab instead of always focusing or creating a Scene View tab.
• Now the Hierarchy View has a toolbar too.
• API Compatibility setting in player settings lets you choose your mono profile. Use 2.0 if you're having trouble with 3rd party assemblies (2.0 not available for web player).
• High resolution icon support for players (Windows: 256x256 and 128x128; iOS: 114x114).
• Search results in project and scene search are now sorted alphabetically.
• Inspector Lock got a real button instead of being hidden in a menu.
• Rotate Tool now includes 'Look At Point' option when Shift + Control/Command keys are held.
• Audition audio in SceneView. Scene view search now filters audio sources as well.
• Added Web Player build templates.
• It is now possible to update Asset Server project to specific revision through command line.

New Graphics Features:

• Static Occlusion Culling using Umbra sPVS.
• Geometry Batching: static and dynamic batching from Unity iPhone 1.7 comes to all platforms.
• Rendering paths: (choose in Player Settings or per-Camera; documentation)
  • Deferred Lighting. A deferred rendering scheme, where realtime lights are not horribly expensive anymore. Lighting cost is only dependent on the number of pixels it touches, so you can have lots of small lights for cheap.
  • Vertex Lit. This makes all shaders & lights use fixed function per-vertex lighting. In exchange, this is fast; primarily targeted at mobile platforms and low-end web.
  • Forward rendering path had lots of changes compared to Unity 2.x, see below.
• Surface Shaders - a much easier way to write shaders that interact with lighting. We don't have the docs for it yet; you'll have to trust us that it's awesome!
• Speed! We have optimized the rendering code; it's often 20-50% faster than 2.6 in the same scene setups.
• OpenGL ES 2.0 for iOS and Android. You can use shaders for objects, post-processing effects etc.
  • Regular Cg/HLSL shaders and Unity 3 Surface Shaders will be cross-compiled into GLSL behind the scenes. Resulting GLSL will be optimized as well, because mobile platforms are not very good at optimizing the shaders.
  • Of course, since mobile platforms are not very powerful, you should use OpenGL ES 1.1 if possible.
• Particle Rotation: Particle.rotation, Particle.angularVelocity and respective properties in ParticleEmitter.
• Soft Particles! When you use Deferred Lighting and have Soft Particles on in Quality Settings, particles will fade out close to intersections with the scene. All built-in Particle shaders (except VertexLit) support this.
• Shadowing improvements: use native shadow maps on Direct3D (faster, less memory, native filtering); much reduced self-shadowing artifacts; Soft shadows support for Point lights; much less "shadow halos" around objects for directional light soft shadows; optimized shadows for Forward rendering path (shares depth buffer with main rendering); optimized shaders for directional light shadows.
• Terrain: Added slider (under Terrain Settings) to control detail object density.
• Vertex shaders for Shader Model 3.0 on Direct3D9 and GLSL on OpenGL can read from textures.
• Skybox is rendered after opaque geometry. Improves performance if your application is fillrate bound.
• Separate Alpha Blending: use Blend ColorSrc ColorDest, AlphaSrc AlphaDest in ShaderLab.
• In-editor visualization on which objects would use which rendering paths (green/yellow/red for deferred/forward/vertexlit).
• #pragma glsl for compiling Cg/HLSL shaders into GLSL instead of ARB assembly programs on OpenGL.
• Compiling shaders to #pragma target 3.0 allows 512 texture indirections on OpenGL (up from 4).
• Development standalone players on Windows have Direct3D PIX events; useful if you use PIX, Intel GPA or other graphics performance tools.
• Fog just works on Direct3D with Shader Model 3.0 shaders, on OpenGL with GLSL and on OpenGL ES 2.0. Additionally, there's no need to write #pragma fragmentoption ARB_fog_exp2 in your shaders anymore; just remove that line.
• CameraDepthTexture modes can be combined if you want to get both depth & depth+normals textures.
• It is possible to forcibly disable Anisotropic filtering on a texture, even when Quality Settings have anisotropic on all textures. Just set anisotropic slider on the texture to zero.
• Uniformly scaled objects will no longer be pre-scaled before rendering - instead uniform scale is now natively supported by the renderer.
• Cg/HLSL VPOS (pixel position) pixel shader input semantic is supported now.
• Terrain: Expose detail resolution per patch; previously was hardcoded to 8.
• Terrain: Improved performance of painting textures & detail objects.

Asset Pipeline Improvements:

• Upgraded to FBX SDK 2011.2.
• Import support for stepped and linear keys for position curves; improved compression and curve fitting for position curves.
• Settings for allowed animation compression error in mesh importer.
• Implemented support for importing 1 unit in 3dsmax as 1 unit in Unity (the default is 1 cm in 3dsmax as 1 unit in Unity).
• Implemented import of tangent space from FBX, .max, .mb and .ma files.
• Switched Cinema4D import process to work in background mode.
• Support for Cinema4D R11 on Mac OS X.
• Support for FBX2010 format when exporting from Cinema4D.

Audio Improvements:

• Filter components: Reverb, Echo, Distortion, Chorus, High- and Low-pass. Can be applied to each audio source or globally to the listener.
• Reverb Zones: Apply reverb to main audio output, when the listener is within zone(s) defined by a position and min/max radii.
• Live output and spectrum data access from each audio source or globally from the listener.
• Tracker/Mod file support.
• Sample-accurate synching. Sources played in the same frame are always started at the exact same point in time. Sources can be delayed and played in the future on an exact sample accurate boundary with .Play(int64 delay).
• Surround sound (7.1, 5.1, 4.0, ProLogic DTS) support.
• Attenuation curves for volume, spread, panning and lowpass filter factors.
• Doppler factor per audio source.
• AudioSource prioritization.
• iOS latency settings. Choose between Default, Best Performance, Good Latency and Best Latency.
• Asset memory is freed after loading audio data.

Physics Improvements:

• Upgraded PhysX to 2.8.3.
• Cloth and clothing simulation: use the new InteractiveCloth, SkinnedCloth and ClothRenderer components.
• Layer based ignore collisions: use the Physics inspector or Physics.IgnoreCollision().
• Continuous collision detection, to make sure that fast moving colliders will not pass through other colliders. See Collider.collisionDetectionMode.
• Added Physics.SphereCast() and Physics.CapsuleCast() to implement volume raycasts.
• Added Rigidbody.SweepTest() to check if a Rigidbody would collide with anything if moved into a certain direction.

New Scripting Features (documentation):

• Mono Develop for script editing and debugging! Documentation.
• Upgrade Mono and C# compiler to Mono 2.6.3. This brings C# 3.5, variable type inference, lambda expressions, LINQ and more.
• New UnityScript compiler: generics, interfaces, structs, type cast operator, anonymous functions/closures, lambda expressions, function types, type inferred array comprehensions and more.
• New Boo compiler.
• Mono class libraries derived from Silverlight profile for the web player.
• Socket security sandbox implementation. Just like Flash (think crossdomain.xml).
• WWW class security sandbox implementation. Just like Flash (think crossdomain.xml).
• Per-platform script defines. Use UNITY_EDITOR, UNITY_WEBPLAYER, UNITY_IPHONE etc. Documentation.
• Improved UnityScript compilation speed.
• New scripting API functions (documentation). Some highlights:
  • WWW.responseHeaders will contain the response headers received from the HTTP server.
  • Application.isWebPlayer.
  • SystemInfo.graphicsPixelFillrate to query GPU pixel fillrate. Returns fillrate for about a thousand GPUs out there.
  • GL.ClearWithSkybox.
  • Math functions: MoveTowards to Mathf, Vector2, Vector3, and Vector4; Quaternion.RotateTowards.
• Changed Mathf.Approximately to not only be useful for comparing very small numbers.
• Stacktraces have been prettified, useless information is better stripped from stack traces.

Other Improvements:

• Web Player: Java and ClickOnce based installer on Windows for true one-click installation process.
• IME input support (for languages like Japanese, which require multiple keypresses to enter a character) on Windows, and in the editor and standalone on the Mac.
• Support for OS font rendering (new "dynamic" font rendering mode), to save space in distribution and texture sizes. Textures are generated dynamically to contain the characters which are needed.
• Documentation: scripting examples in UnityScript; C# and Boo. Docs for all platforms merged and platform specific parts toggle-able.
• Web Player: UnityObject.js script makes Web Player embedding easier.
• iOS: Added cpu-waits-gpu metric in internal profiler; useful for tracking down GPU bound applications.
• iOS: Native resolution support for iPhone 4.
• iOS: Improved game build sizes.
• iOS: Unity Remote 2: It is possible to turn off image syncing between editor and device. Useful for input-critical games.
• OS X Web Player: Now supports NPDrawingModelInvalidatingCoreAnimation, as will be required by future versions of Chrome.
• Networking: RakNet upgraded to version 3.732
• Networking: Connection tester, Network.TestConnection(), now reports your NAT implementation type more accurately.
• Networking: Exposed Network.logLevel so you can change the amount of log output at runtime.
• Networking: Added network GUID, used for NAT punchthrough.
• Bug Reporter: Supports multiple file attachments; trims attached log files if they are too large.

Some Changes We Did

We thought you might want to know about them... Read more in the docs.

Graphics Changes:

• Forward rendering path had lots of changes:
  • Most common case (one directional per-pixel light) is drawn in one pass now! (used to be two passes in 2.x)
  • Point & Spot light shadows are not supported. Only one Directional light can cast shadows. Use Deferred Lighting path if you need more shadows.
  • Most "Vertex" lights replaced with Spherical Harmonics lighting.
  • Forward rendering path is purely shader based now, so it works on OpenGL ES 2.0, Xbox 360, PS3 (i.e. platforms that don't support fixed function rendering).
• Shader & ShaderLab changes:
  • If you want to write shaders that fully interact with lighting; it's best to use Surface Shaders.
  • Unity 2.x per-pixel lit shaders will need to be manually converted to surface shaders or manually fixed.
  • Shaders are compiled to more targets by default (e.g. OpenGL ES 2.0); you might hit some places where OpenGL ES 2.0 does not like some Cg/HLSL constructs. Either fix the offending places, or exclude shader from OpenGL ES 2.0 via #pragma exclude_renderers gles.
  • Lots of sanitization to built-in variable names (mostly to accommodate new OpenGL ES 2.0, Xbox 360, PS3 platforms).
  • Unity 3.0 will automatically upgrade most of 2.x shaders for syntax changes. This actually modifies your shader files (look for "Upgrade NOTE" in your files).
• Normal map compression; just mark texture as Normal Map and will be DXT5nm compressed at decent quality. All shaders need to use UnpackNormal(n) instead of n*2-1.
• Remove concept of "RECT" textures. All non-power-of-two RenderTextures are addressed with 0..1 UVs now (just like in D3D9 in Unity 2.x).
• Parallax shaders get height from a separate texture now.
• Self-Illuminated shaders get illumination from a separate texture now.
• Terrain lighting modes (Vertex/Lightmap/Pixel) are gone. Terrain is lit just like everything else now.
• When rendering with Shader Replacement, no lighting is ever applied. Skybox, GUI, Halos, Projectors are not rendered.
• Background shader queue is treated like Geometry now (arbitrary sorting, assumed to be opaque).
• OnBecameVisible/OnBecameInvisible have slight behaviour changes. For example, now they are not called each frame on a shadow caster that is not visible itself.
• Self-Illuminated materials calculate emissive color as (material color * texture * illumination); previously was (texture * illumination).
• Simplified Shadow Bias setting on Lights.
• Depth render textures on D3D9 use native depth buffer. Value distribution changed from linear to z-buffer like (just like in OpenGL).
• Spot lights attenuate exactly like Point lights now.
• Point lights with Cookies actually attenuate now.
• OnRenderObject script callback behaviour changed. Now those callbacks are called after everything is rendered; not at points in the middle of rendering.
• Changed the way the Camera-DepthTexture and Camera-DepthNormalTexture shaders are loaded so that they can be overridden when needed.
• Custom Tree shaders specify their billboard shader via Dependency keyword now (instead of Tag). The billboard shader will be automatically included in the build.
• Screen space coordinates should use float4 on all platforms (used to be V2F_SCREEN_TYPE). When sampling a texture with tex2Dproj, use UNITY_PROJ_COORD macro around it.
• Added WorldSpaceViewDir() and WorldSpaceLightDir() functions to UnityCG.cginc.
• Obscure Graphics Changes That No One Will Probably Notice ^TM: documentation.
• Renamed the 2.x tree shaders and the 3.x Tree Creator shaders; both are put under "Nature" section.
• OnPreCull, OnPreRender, OnPostRender and OnWillRenderObject messages are not sent to disabled behaviors.
• Old Unity 2.x Lightmapped shaders moved under "Legacy Shaders" submenu.
• Terrain: Removed the concept of grayscale lighting from terrains.

Editor Changes:

• Unity Editor on Mac OS X requires Intel-based Mac and OS X 10.5 "Leopard" or later.
• Removed Soft Vegetation option from Quality Settings UI. It does nothing in built-in shaders now.
• Separated preferences for 3.x and 2.x editors.
• Removed ancient Dinosaur graphics emulation.
• Moved "All compile errors must be fixed" notification to scene view notifications (moved it out of console).
• Made the curve editor send a CurveChangeCompleted event when the curve change has been completed.
• Create New Project dialog now expects user to select an existing, empty folder on the Mac
• Mesh Import option "Split Tangents" is on by default.
• Texture Importer:
  • Bump maps are now referred to as "normal maps" in the editor.
  • Normal maps are labelled as "NM" in their format.
  • PVRTC compression level moved to advanced settings.
  • Generating a Cubemap will make the cubemap be the root asset.
  • Textures that only use one value across the whole alpha channel and that value is not 1 are marked as needing-alpha-channel.
• The command and control key modifiers in the view tool have been switched on OS X. Now command moves and control zooms. Control still moves on Windows.

Physics Changes:

• Rigidbody mass is no now longer limited to 10000.
• RaycastCollider is now deprecated.
• Center of gravity and inertia will now always be automatically recalculated when setting or animating collider properties or positions, unless they had been explicitly set from code before.
• Slope limit on character controller now works properly above 45 degrees. When loading old scenes the value will be clamped to 45 degrees to mimic the old behaviour.
• JointDrive.maximumForce will now also be taken into consideration when JointDrive.mode is JointDriveMode.Position. You may need to change your joint setups so that they still work.

Unity iOS Changes:

• iPhoneStreamingAssets is renamed to StreamingAssets and is now located under the Assets folder (visible from within the Editor).
• Target iOS Version field added to player settings. Now deployment target can be specified separately from active SDK version.
• "Enable Unity Networking" flag removed from iOS player settings. Now stripping of networking is handled automatically.
• Most iPhoneInput members moved to Input class.
• Native plugin support added to both Basic and Advanced Unity iOS licenses.
• Added support for iPad / iPhone Simulator
• Hardware audio decoder is now shared between audio clips.

Other Changes:

• Random number generator (Random class) was changed. It is marginally slower, but produces better "randomness", especially in lower bits. Additionally, integer version is not limited to 15 bits range.
• Internal Random number generators (for Particles etc.) are reset after each level load. Now your particles in any level do not depend on what levels were loaded before.
• The default runtime font is now Arial 13, as rendered as a dynamic font on Mac OS X and Windows.
• Scripting: Renamed WWW.data to WWW.text
• Scripting: ScriptableObject derived classes must be instantiated using one of ScriptableObject.CreateInstance overloads.
• Scripting: UnityScript strict mode no longer allows arbitrary downcasts from Object (unless #pragma downcast is used).
• Input: Keyboard on MacOS X will now reflect the behavior on Windows (two separate KeyDown events for key code and character, KeyUp event only for key code).
• Scripting: Removed support for .NET 1.1 profile.
• Scripting: Made previously undocumented GUIClip class internal to UnityEditor.
• Networking: Connection tester now requires 4 public IP addresses to work.

Here, I Fixed It!

We fixed some things as well...

Editor Fixes:

• General: Improved Undo behaviour.
• General: Game View Stats window has more accurate frametime & FPS display.
• General: Don't enter Play mode if there are compiler errors.
• General: Debug.LogWarning will not pause the game if console has Error Pause selected.
• General: You can now search for script derived types in the project window (when Type is selected).
• General: Fix newly created materials in project view sometimes having empty names.
• General: Reset menu option is now undoable.
• General: Fixed importing standard packages into projects with non-Latin characters in path on Windows.
• General: Fix occasional exceptions with Undo when asset inspector loses selected assets.
• General: Fix editor window sometimes shrinking into the corner when changing layout presets on Mac OS X.
• General: Fixed a bug where selecting a scriptable object with a missing script reference would result in null reference exceptions
• Crash: Fixed crash when deleting the last item in an array of strings.
• Crash: Fix crash on Windows when undocking Game View.
• Crash: Fix crash caused by EyeDropper picking color on different monitor.
• Crash: Editor is more resilient to missing object references (eg. a Unity iPhone 1.7 upgraded project was crashing the editor on play).
• Inspector: "Open Compiled Shader" in Shader Inspector works more predictably and uses text editor chosen in preferences.
• Inspector: Fixed display of boolean arrays.
• Inspector: Fixed Material/Mesh/Object previews being affected by scene Fog.
• Inspector: Fix "Any" Texture properties in Materials using the wrong GUI style.
• Inspector: Fixed bug where opening a terrain inspector would dirty the terrain causing it to get saved although nothing had changed.
• Asset server: Fix editor hanging on OS X when trying to merge conflicting text assets.
• Asset Server: Fix unable to update when parent of file modified on server is locally deleted.
• Asset Server: Cleaner Diff output when comparing binary files in Asset Server.
• Asset Server: Fixed asset server caching failing in some cases (e.g. when using EditorUtility.CopySerialized).
• Importing: Tangents will be properly handled when mesh compression is enabled.
• Importing: Fixed direct import from Maya 2011.
• Importing: Using TextAsset to store binary data now actually works, as long as your file has the .bytes extension.
• Importing: Cylindrical cubemap projection generation now works.
• Importing: On rare occasions Unity Editor on Windows was throwing 'Writing file error' while reimporting all assets and anti-virus running in the background.
• Importing: Fix texture object fields in cubemap inspector losing the thumbnail when reimporting.
• Importing: Shader files with uppercase file extensions are properly imported now.
• Importing: Reduced memory usage during texture import.
• Importing: Better memory handling when importing assets, switching scenes, building player.
• Importing: FBX importer gives detailed warnings if it detects problems in the skin of a model.
• Importing: Fixed import of user properties from 3D asset files.
• Importing: Fixed import of multiple animation takes.
• Scene View: The grid is now also shown in Iso mode.
• Scene View: Terrain is selectable in Scene View just like any other object!
• Animation View: Margins are now fixed instead of a percentage.
• Animation View: Improved handling of window resize.
• Animation View: Make create key operations work better for steep curves and disallow it for read-only curves.
• Animation View: Prevent creating keys outside of permitted horizontal range.
• UI: Maximized state of main editor is remembered across sessions on Windows.
• UI: Don't show Project Wizard or Welcome Screen if Reimport All was invoked.
• UI: Fix some of context menus not being properly validated (grayed out) on OSX.
• UI: EditorWindow.Notification now properly shows white text.
• UI: Clamp profiler frame selection dragging correctly.
• UI: Fixed animation icons being clipped in the inspector.
• UI: Fixed dragging tab on Windows putting window title bar above the screen top.
• UI: Show error message if -nographics is used without -batchmode.
• UI: In Package Import Dialog selecting checkboxes will now correctly affect child elements.
• UI: Fixed Asset Server tooltips in Overview window getting too large and disappearing too soon.
• UI: Fixed old regression where pressing F to frame selection frames selected object in last active scene view, if active window doesn't use frame selection event.
• UI: When editor is processing something on Windows, made utility windows not be on top of all application windows in the system.
• UI: Fix error messages when trying to move file to the same folder via Project view on Windows Vista or 7.
• UI: Fixed icons for sub-assets in search view.
• UI: Show proper cursor when trying to drag files out of Unity Editor on Windows.
• UI: License Info word wraps properly in About Window.
• UI: Fixed the eye dropper color picking tool disabling itself when the mouse is moved too fast.
• UI: Fixed editor not finding GUI styles on computers with some of non-English locales.

Rendering Fixes:

• Driver workaround: Fixed occasional crash on some Intel graphics cards when shader uses mismatching texture types.
• Driver workaround: Disabled anti-aliasing on Macs (pre-Snow Leopard) with GeForce 7300 graphics cards; occasional driver crashes.
• Driver workaround: Disabled mip-mapped Render Textures on Macs with Intel GMA 950 cards; occasional driver crashes.
• Driver workaround: Fixed garbage on Macs with GeForce 7300 GPUs. Had to disable Deferred Lighting on those cards though.
• Particles: Particle color and UV animation will now be based on the lifetime of each individual particle instead of the max energy set in the emitter.
• Shadows: Spot light shadows fade out correctly on D3D9.
• Shadows: Fixed point light self-shadowing artifacts which were mostly happening on Mac.
• Shaders: Using more than 8 textures in a pixel shader works now!
• Shaders: Nested block comments (/* foo /*bar*/ */) are supported now.
• Shaders: Fixed error messages sometimes being printed when both GLSL and non-GLSL shaders are present in the scene.
• Shaders: When there are Direct3D shader assembly errors, print the shader name in the error message.
• Shaders: Fixed instruction count reporting for D3D9 assembly shaders.
• Crash: Fixed crash if accidentally setting invalid shadow cascade count in Quality Settings.
• Crash: Fixed crash when shader has unterminated block comments.
• Crash: Fixed crash when shader tries to fallback to itself.
• Terrain: Fixed various issues with terrain billboards (non-uniform scale, culling, mismatch between root of the billboard and the mesh etc.).
• Terrain: Fixed too aggressive culling of billboarded terrain details.
• Terrain: Fixed terrain blocking MouseDown events from scene view gizmos.
• Terrain: Made it possible to use trees with only one material.
• Terrain: Now actually use the tree cutoff value that is set on the material.
• General: Fixed half-texel offset issues with Graphics.Blit on D3D9.
• General: Removed rect clamping for camera's normalized viewport rectangle.
• General: Fixed texture binding on iOS/Android; textures won't become corrupted when loading levels now.
• General: Custom Fonts will now be properly displayed by Unity GUI.
• General: Fixed AABB calculation for just-unloaded Meshes and skinned meshes with no bones.

Unity iOS Fixes:

• Fixed iPad Simulator 3.2 support
• Fixed stripping issue which caused crashes when coroutines are used.
• Fixed WWW.text and "Fast but no exception" problem.
• Fixed a crash when using AnimationCurve property in a script.
• Fixed input processing on iPhone 4 with native resolution.
• Fixed video player orientation on iOS 4.

Physics Fixes:

• Meshes created with Mesh.CombineMeshes will correctly collide when used with MeshColliders.
• Make WheelHit report correct sidewaysDir.
• Make raycasts work when Time.timescale is zero.
• Kinematic or sleeping rigidbodies will now properly update their internal PhysX state when a parent rigidbody gameObject is moved.
• Collision events are sent more properly now.

Scripting Fixes:

• WWW.text respects content-encoding specified in HTTP response headers.
• Debug.Log is now thread safe.
• Fixed internal UnityScript compiler error caused by nested arrays.
• Fix crash when opening a project where a script throws an exception in a static constructor.
• Fixed crash caused by untyped or wrongly typed parameter of message handler.
• Fixed crash when DestroyImmediate is called in user code and Unity doesn't expect the object to be destroyed.
• Material.CopyPropertiesFromMaterial() now works as expected.
• GameObject.SampleAnimation respects the WrapMode of the clip.
• UnityGUI: Fix GUIUtility.RotateAroundPivot and ScaleAroundPivot using screen space pixels instead of clip space pixels.
• UnityGUI: Fix ScrollViews not properly ignoring DragPerform/DragUpdated events.
• UnityGUI: GUILayout.Toolbar now correctly calculates toolbar size.
• Fixed a typo bouncyness in Physics Material, now it's spelled correctly bounciness.
• Fixed a crash when setting negative values for particle minEnergy, maxEnergy through a script.
• Issue an error when the script class name and file name do not match (after script has been attached). Similarly issue an error if a class was changed to be abstract or was turned into an interface.

Networking Fixes:

• Timestamps are now correct in received NetworkView RPC messages.
• Network.useNat has been deprecated. It is now set automatically when you Connect (since you can now only connect with NAT punchthrough using a GUID) and is set in the InitializeServer function call explicitly.
• You can now connect using a HostData struct received from the master server (correct method automatically used) and give a connection password when connecting with GUIDs.
• Fix server crash when player with network views disconnects.
• Fix for problem when using Network.Instantiate after loading a new scene.
• Fixed problem with master server not returning local IP addresses when it should (when host/client are on the same router/external IP).
• Network.TestConnection() now always returns error status correctly. To restart a test after getting an error it needs to be forced with the appropriate parameter.
• Fixed network scope bug which resulted in state sometimes not being synchronized correctly.

Other Fixes:

• Fixed saving screenshots to non-ASCII path names.
• Web Player: Fixed some memory leaks.
• Fixed various corner cases in AnimationEvents logic.
• Audio + iOS: Make UnitySetAudioSessionActive(true/false) actually work.
• Audio: Fix crash when trying to access AudioListener and it doesn't exist.
• Player: fix some of movies playback crashing web and standalone players.
• BugReporter: Escape special characters in bug description.
• Web Player: Fixed one frame of garbage showing when going out of fullscreen mode in CoreAnimation plugin on Mac OS X.
• Audio: AudioSources with PlayOnAwake checked, now plays in the first frame (and can be accessed correctly from Start() and Update()).
• Audio: .time & .timeSamples can now be set before playing AudioSource(s)
• Bug Reporter: Do not terminate the if the bug submission fails (Mac).
• Fixed WWW.uploadProgress crashing the web player (this property still is not fully implemented though).
• UnityGUI: Fix Vertical Margin error for GUILayout groups with multiple elements.
• Web Player: Several fixes to make it work better with Google Chrome on Mac OS X.

Known Issues

• MonoDevelop: Single-stepping outside the control flow of a script while debugging results in decreased performance until normal execution continues.
• A flaw in the way 64 bit Windows OS handle structured exceptions for 32 bit applications can cause crashes in Unity players. The issue may surface, for example, if a player running on a 64 bit Windows causes a NullReferenceException to be thrown, even if the exception is handled. This bug affects all 32 bit applications running on 64 bit Windows, including Microsoft .NET applications.
  A hotfix solving the issue is available on support.microsoft.com, but of course this does not help your end user. Your best bet is to keep your players exception-free (which is always a good idea), at least until the fix is distributed to end users via Windows update.
• Touch.deltaPosition and Touch.deltaTime can be inaccurate on Android.
• Tree Editor Leaves can not be manually rotated.
• Debugger: Does not halt on some exceptions thrown from internal Unity engine code.
• Build Settings Window may not initially react to mouse clicks. Workaround: move/resize the window.
• Generate Lightmap UVs: the results may be different on mac and windows. If you encounter this problem, please report a bug.
• Generate Lightmap UVs: performance degradation is expected on highly tessellated mesh. This will be fixed in subsequent releases.
• Graphics: Anti-Aliasing does not work with Deferred Lighting.

Memorable Quotes

3AM the night before the beta release:
Joachim: If we do this we should do it right
Nicholas: This is going to be fun. I've never written threaded code before…

Unity 2.6

Unity 2.5

Improved Usability

Find the tools you need quickly and easily. The Play buttons are front and center, clearly visible and inviting you to play, test, and improve your work. And when you do, they light up, dimming the rest of the application, drawing your attention to the most important things in the play experience you're creating.

Precise Navigation and Placement Tools

Snap any object to customizable increments of position, scale, and rotation values. Drag objects around, clamped to any surface collision. Manipulate objects in local or world space. Use the new flythrough controls to get around easily. And did we mention the completely redesigned rotation tool?

3ds Max Importing

Drag and drop your .max files right into the Editor, including support for all skeletal based animation, multiple UVs, and vertex colors. Autodesk 3ds Max now joins the existing support for Maya, Blender, and all other 3D applications that integrate with the latest FBX plugin on the Windows platform.

Completely Customizable Editor

UnityGUI, Unity's own GUI creation system, now powers the entire Editor and allows you to integrate your own unique level design tools, AI control tools, debugging tools, difficulty tuning tools, or anything else you need. Over 130 new API entry points enable you to create specialized, customized editor tools and build them into the existing Editor interface.

Tabbed Interface

We took cues from the best designed applications, and the rewritten editor has received dozens of improvements. The most visible change is the tabbed interface, where every part of the interface can be moved, undocked to a secondary monitor, and even stacked to achieve logical grouping.

Information at Your Fingertips

We've gone to great lengths to make sure that you always have the info you need, when you need it. Model files have previews right inside the inspector. Audio Clips show their waveform with click-to-play behaviour. Meshes show the detailed rendering stats – and that's just scratching the surface.

Additional features, improvements, and changes

Of course we did not just rewrite the editor. We also added some features and fixed some rough corners.

Graphics & Shaders:

• Multithreaded mesh skinning. Multicore processors, here we come!
• Runtime DXT compression. See WWW.LoadImageIntoTexture and Texture2D.Compress.
• Shader Level of Detail support. See Shader.maximumLOD, Shader.globalMaximumLOD.
• RenderQueue can be set per-material from script, see Material.renderQueue.
• Optimized rendering internals.
• Shader compilation is about 3x faster now!
• Added #pragma exclude_renderers and #pragma only_renderers directives to shader compiler, to be able to write D3D-only and OpenGL-only shader paths.
• Optimized UnityGUI rendering, now it generates less vertices when it can.
• NVPerfHUD is supported in Windows standalone games.

Web Player:

• Google Chrome browser support (had input problems and crashes on early versions of Chrome).
• Internet Explorer 8 support (had input problems when running on Vista).
• Windows Web Players have much more stable frame rate.

Editor:

• Asset Server client interface completely rewritten. Change-set based interface, log history, and so on!
• Scene view can visualize overdraw & optimal texture resolutions (added to RGB/Alpha mode popup).
• FBX importing libraries updated to latest version. Fixes lots of issues with FBX, Collada, OBJ, DXF file importing.
• FBX user properties are exposed to asset post-processing scripts, see AssetPostprocessor.OnPostprocessGameObjectWithUserProperties.
• Added Global transformation tools mode.
• Game view Stats window displays frame time and frames per second.
• Arrays of enums are properly shown in Inspector.
• Added "Show Project Wizard when launching" option to Preferences.
• Custom Script/Image editing applications are remembered in Preferences.
• Added Terrain wind tint color to terrain settings. Previously it was a hardcoded value.
• Added gizmo for Spring Joint and improved gizmos of other joints.
• Make default setting for "Recalculate Normals" be off in mesh importer.
• Added progress bars for import/export package operations.

Other Improvements:

• Application.targetFrameRate. If you want to cap the maximum frame rate to save the planet – now you can!
• AnimationClipCurveData has target variable now.
• Improved UnityGUI text fields. Now they scroll with cursor if content is too large to fit; selection and cursor display were improved.
• Unity on Windows is "large address aware" – so on 64 bit Windows it can use up to 4GB of memory.
• Licensing changes: Unity can build standalone games for any platform (they will show splash screen). Unity builds web players with a watermark that goes away after a short period of time. With Unity Pro the splash screen and watermarks are optional.

Bug Fixes

Editor Fixes:

• Fixed Character Kerning inspector for custom fonts.
• Fix error message when importing Font from a FAT32 filesystem on OS X
• Fixed Rotate tool handle location changing with complex hierarchies when it's in Center mode.
• Fixed Joints that are connected to themselves.
• Fixed Mac vs. PC byte orders in terrain .raw files being swapped.
• Mass Place Trees is properly undoable.
• Switch texture format to one that has alpha channel when Generate Alpha from Grayscale is enabled.
• priority parameter for MenuItem attribute actually works now.
• Fixed crash when importing some TrueType fonts.
• Error Pause in the console works for script exceptions.
• In Cubemap inspector you can create cubemap from skybox images without having to mirror them.
• Gizmos.color and Gizmos.matrix are reset before calling any gizmo functions.
• Fixed importing progress bar for movies without audio.
• Fixed terrain lightmap shaders not working in editor on some old cards (e.g. GeForce 2).
• Mesh importer was putting random values into normals and tangents of unused vertices.

Web Player Fixes:

• OS X web player correctly clips the game area if it does not fit on screen.
• Work around a bug in Vista + Internet Explorer 8 (RC1) where going fullscreen hangs up the browser. Now fullscreen is disabled there :(
• Work around Firefox 3.0.x scripting interface bug on OS X that made some games not work.
• Fixed non-focused web players able to read keyboard input.
• Fixed OS X web player flicker while scrolling in Firefox.

Graphics Fixes:

• Fixed Camera.RenderWithShader in some cases messing up image effects if called from inside of OnPreRender.
• Fixed Water becoming blocky on some Intel cards when game is running for many hours. Update Standard Assets and Pro Standard Assets to get the fix!
• GUI.DrawTexture fixes: can handle non power of two render textures; fixed 50% opacity when there's no other UnityGUI used; correctly takes GUI.BeginGroup clipping rectangles into account.
• Rendering Stats window gathers any rendering done during Update and other functions. Rendering through GL class is captured now as well.
• Reported VRAM size should be more robust now on OS X (previously was reporting 256MB for some 512MB cards).
• Fixed Texture2D.ReadPixels being upside down when reading from render textures on Windows.
• Fixed TexGen ObjectLinear not producing correct texture Z coordinate.
• Fixed Movie Textures leaking some memory.
• Fixed occasional movie playback crash when movie is more tall than wide and is not power of two in size.
• Fixed Camera.SetReplacementShader not taking the tag value into account.
• Fixed particle rendering in orthographic scene view.
• Fixed large GUI areas clipping off last pixel row/column on Radeon HD graphics cards.
• Fixed crash in Graphics.DrawMeshNow if there is no current camera.
• Fixed setting mesh.triangles corrupting data when mesh has multiple submeshes and you set a smaller triangle array.

Documentation Fixes:

• Much better documentation for Editor scripting API.
• Attributes are on a separate page in scripting reference.
• Fixed scripting reference search not finding some words (e.g. Mathf.Sign)
• Fixed broken links in printable documentation (printable.html)

Other Fixes:

• Unicode love:
  • Various Unicode character input fixes for Unity GUI.
  • Standalone Windows games can launch from Unicode paths or when Project Name contains Unicode characters.
  • Fixed Paste with some Unicode strings not working.
  • Fixed Font.HasCharacter() for some characters.
• Seeking in compressed audio (with .time) now works and with a much better precision.
• Animation fixes:
  • Fixed Animation.Sample() not working if animation was not playing before.
  • Fixed Animation.CrossFade and Stop not clearing out queued animations.
  • Fixed Animation.IsPlaying for queued animations.
• Fixed Application.loadedLevel being initially -1 in players.
• Fixed Mesh.tangents producing null reference exception if mesh had no normals nor tangents.
• Fixed EventType.ScrollWheel delta values being about 100x too large on Windows compared to OS X (now they match OS X).
• Fixed copying text into clipboard producing extra ASCII zero character at the end on OS X.
• Fix unrecognized keys (like volume up/down on some keyboards) triggeting unrelated input axes on Windows.
• Fixed Mathf.Ceil and Mathf.CeilToInt returning next integer number if the argument was integer already. D'oh!
• Fixed audio playback from streamed Ogg files.
• Fixed crash when streamed video download is cancelled.
• Fixed terrain tree colliders for terrains that aren't placed at zero.
• Fixed MovieTexture playback issue.

Unity 2.5.1

Unity 2.5.1 is all about stability of the Editor, Web Player and other fixes. Some stuff that was missing in 2.5 has been improved, and some other outstanding issues should be solved. See below.

Improvements:

• Scene view Gizmos are pickable again, just like they were in Unity 2.1. Gizmo picking is improved when multiple gizmos overlap the same screen area.
• Improved Scene View performance when very large hierarchies are selected.
• Cubemap preview in Editor Inspector now actually works.
• WWW class supports SSL (https) in Windows Editor and Standalone games
• Decreased memory usage of Asset Bundles by 8MB per bundle (decompression dictionary was kept around for no good reason)

Changes:

• Screen.SetResolution and Screen.fullScreen do not switch resolution immediately; instead resolution change happens when the current frame is finished.

Editor Fixes:

• Fixed occasional random crashes when working in the Editor (recompiling scripts, popup menus, custom ContextMenu attributes etc.)
• Fixed input keys&buttons getting "stuck" in Windows Editor (switching between applications, un-pausing the game)
• Fixed some cases where switching user, entering screen saver or standby mode would make Windows Editor GUI not update anymore.
• Building an OS X Standalone player on Windows properly strips symbols now
• Fixed Font importing on Windows when folder or file name has non-ASCII characters
• Fixed current scene being marked as modified when showing Material Inspector
• When building a player using BuildPipeline, level path names are converted into forward slashes as path separators. Fixes levels being named like "Assets\Foo.unity" (instead of "Foo.unity") on Windows.
• Showing invalid Tag no longer produces errors in the Editor
• Fixed '/' and '%' in Asset Server commit messages being interpreted as menu shortcuts
• Fixed file comparison problems in Asset Server
• Fixed exceptions in Editor when changing Game Object Active or Layers in non-recursive mode
• Fixed error in Editor when deleting Movie Texture that is currently displayed in Inspector
• Fixed crash when doing Reimport All from Project View's context menu in Windows Editor
• Fixed crash when importing some malformed .3ds files
• Fixed hidden / CVS files appearing in Project View when manually reimporting asset folders
• Fixed Unity Editor crash when Data Execution Prevention is used on Windows
• Fixed audio files sometimes missing samples at the end (OS X only)
• Fixed loading editor preferences when user has changed system locale
• Fixed terrain heightmap editing crash when the same terrain is instantiated multiple times in the scene
• Fixed Frame Selected on skinned meshes and transform hierarchies
• Non-skinned Custom deformer weights are properly ignored when importing FBX files
• Inspector properly updates when changing Script component to reference another script
• Set Terrain Resolution button no longer says "Import"
• Fixed errors on Windows when dragging files into Project View from some applications
• Fixed Help icons in Inspector appearing at startup for non-existing help pages

Web Player Fixes:

• Fixed auto-update problem on Windows Vista + UAC + Internet Explorer. See tech note below.
• Fixed web player crash on Windows Vista when locale is set to Spanish
• Fixed issue with mixing Unity and Flash content (by hiding one or another) on Internet Explorer (regression in Unity 2.5.0)
• Fixed Tabbing through UnityGUI fields not working on Internet Explorer
• Fixed crash on Mac OS X when exiting fullscreen mode
• Fixed auto-update problem on PowerPC Macs
• Fixed Input.mousePosition being incorrect when using Application.targetFrameRate on OS X Web Player
• Fixed occasional crash when reloading web player on OS X
• Null Reference Exceptions don't crash on OS X + Firefox 3 anymore
• Fixed Firefox 3.0.10 issues on OS X Web Player

Other Fixes:

• Various scripting reference documentation fixes
• GUI.depth now works again
• TextAsset can contain arbitrary binary data again
• Fixed Mono memory leaks on Windows (allocating large managed arrays, leaked script assemblies)
• Fixed Input configuration dialog in standalone games on Windows (keyboard configuration was broken in 2.5.0)
• Fixed regression in existing Unity 2.0-2.1 content that was using Event.current outside of OnGUI
• Fixed UnityGUI regression with custom1..custom20 GUI styles
• Fixed Screen.lockCursor making Screen.showCursor not work on Windows
• Fixed terrain billboards being culled too early and trees culled incorrectly in some cases
• Fixed crash when unloading asset bundles
• Fixed Movie streaming via WWW class
• Fixed occasional crashes when switching the screen resolution in the middle of frame on Windows
• Fixed crash when setting .time on an audio clip that is not playing yet
• Fixed crash when running standalone Windows games from a read only file system

Release 2.5.1 Web Player auto-update Tech Note

During testing of 2.5.1 we have identified and fixed an issue that affects auto-update behaviour of the web player plugin. This tech note explains the issue and the steps that are required to be taken by customers publishing content using Unity 2.5.1 or later.

The Unity Web Player has a mechanism that automatically updates when it encounters content that requires a newer version of the Unity Web Player. In that case Unity downloads and installs an update to the Unity Web Player completely automatically. Under Windows Vista, when UAC (User Account Control) mode is enabled and Internet Explorer is used as the browser, we have discovered a situation where this auto-update will fail.

Under Windows Vista only, when the browser is Internet Explorer, if the 2.5.0 Unity Web Player was installed and Vista's UAC is on, it is impossible for the plugin to be automatically upgraded to 2.5.1. However, a manual install will successfully upgrade the 2.5.0 plugin to 2.5.1.

This issue only happens when upgrading from 2.5.0 to a later plugin. Earlier versions of the plugin (2.1.0, 2.0.2 etc.) do not have this problem. The problem itself is wrong manifest information in web player update application, which makes it not have enough permissions to perform the update on Vista + UAC + Internet Explorer.

To help customers we have changed the default HTML template built by Unity when building web content. The change is in a VBScript snippet we recommend be used on the containing web page to identify which version of the plugin is installed. We have updated the "Detecting the Unity Web Player using browser scripting" page of the Unity Manual. We urge all customers to visit this page, understand the significance of the change and update their HTML pages accordingly. The change recommended is that if the script detects Windows Vista and Internet Explorer and Web Player Plugin version 2.5.0 the page should pretend that the plugin is not installed. The gamer should be recommended to download and install the plugin manually. The Support team at Unity is aware of the issue and can help customers who require assistance with this change.

Upgrade Guide

Unity 2.5 projects are compatible with Unity 2.1, so if you do not use new 2.5 features, you can open your projects with Unity 2.1.

Timeline window for creating animations directly in Unity was removed in 2.5. Of course you can still author animations in a 3D application. This feature will return even better in Unity 2.6 including High-end Curve Editing and support for animating any property including material animation.

Some of the Editor scripting API was refactored, here are the largest changes:

• EditorWindow.OnCloseWindow is removed. Use OnDestroy instead.
• Hotkey part in MenuItem name requires a space character before the hotkey now.
• Removed Mac Ctrl (^) modifier support from MenuItem hotkey.

Unity 2.1

Note: a newer version of Unity has been released since Unity 2.1. Check out the current release notes to find out what's really new.

Unity has evolved to be the perfect MMO and virtual world client, both in the browser and stand-alone. Stream in limitless landscapes as your users travel your universe, customize characters, and load infinite locations and virtual items on demand. When Funcom, makers of Anarchy Online and Age of Conan, decide to use Unity for their upcoming browser based MMO project, you know it has to be good.

Streaming Asset Bundles

Load assets on demand with new web streaming features. You can now stream in your game world as characters, locations, and objects come into view. You can also stream entire levels from the web as you navigate through the world.

Textures, animated models, complete or partial scenes, new missions and expansions, user-generated characters – anything can be streamed.

Streaming asset bundles are a Unity Pro-only feature.

Streaming Terrains

A seamless world is key when making an MMO. With Unity 2.1 you no longer are limited to a single terrain. Immerse your user in an endless landscape, based on streamed data.

Real-Time Shadows on Terrains

For extra kicks, lights and shadow projectors make terrains more distinct. And with Unity Pro, real-time shadows make them even more dazzling.

Real-time shadows on terrains are a Unity Pro-only feature.

Procedural Characters and Animation

It's easy to stitch multiple body parts into one character, and reassign bones to different characters. In order to support fully customizable avatars, the entire skinned animation system is now scriptable.

Tie animation playback to scripted game events using Animation Events.

Response curves can be edited in a Response Curve Editor, using the new Editor Window Extension API.

You can assign arbitrary animation curves to an AnimationClip, and things like material properties can now be animated too.

Even More Editor Extensibility

Need more tools to support your team? With Unity 2.1 there's even more tools to extend the development environment: you can now create completely custom editor windows, and entirely new tools and workflows.

Asset Processing Pipeline

In larger projects, customizing the art pipeline to avoid repetitive steps becomes crucial. You can now complement Unity's famous asset importing pipeline with any additions you need to make it truly flow.

We've added a complete scripting API for pre– and post-processing assets. Want to generate materials slightly differently? Add components to some game objects based on their name? Set up specific texture import settings based on the name of a texture?

Scripted Asset Processing is a Unity Pro-only feature.

Rendering with Shader Replacement

Render the scene, replacing shaders of all objects. This makes it simple to make incredible eye-candy like depth-of-field, soft particles, thermal goggles, and more!

Immediate Mode Rendering

A single function call can render any mesh anywhere, with full per-pixel lighting and custom shader support.

Undo

Yes, undo! Traditional, reliable Undo and Redo are now available for all scene operations. You can stop constantly saving your work – it just works.

Performance

One can never have enough speed. In Unity 2.1, accessing components from scripts is a lot faster. Oh, and we optimized the graphics engine as well.

Additional Features, improvements, and changes

Unity is a lot of things to a lot of people, so of course we added lots more for your development pleasure.

Asset Bundles

• All types of assets in the Project View can exported as a compressed asset bundle.
• The asset bundle file can be streamed through the WWW class. This makes it possible to stream all assets on demand, as characters or other assets come into view.
• Assets in asset bundles can be loaded by name or through a designated "main asset" for easy prefab instantiation.
• Asset bundles can contain additional scene files and their dependencies. This can be combined with asset bundle cross dependencies.
• Asset bundles and all their loaded assets can be unloaded explicitly through AssetBundle.Unload function.

Web Player

• PlayerPrefs now work in the Web Player! Use them to store persistent data on the client machine.
• Joysticks and mice are now hot swappable on OS X web players

Editor

• Undo and Redo for all scene operations!
• Unity Editor can now natively import .DDS texture files.
• Added "Split tangents across UV seams" option to mesh import settings, most often used for bumpmapped characters.
• Arrays of booleans, Vector2, Vector4, Rect, LayerMask are shown in the Inspector now.
• Game View statistics window displays video memory size used by the screen, total video memory usage and skinning/animation statistics.
• Assets->Reimport and Assets->Import Settings now works recursively for folders.
• Help menu and the Console window have buttons to open Editor and Player logs.
• Renamed Open and Save menu entries Open Scene and Save Scene.
• Added warning when importing scripts and shaders that use mixed CR & LF line endings.
• Ogg Vorbis encoding bitrate expanded to 16..320 kbps (previously was 56..256 kbps).
• .ogv files are recognized as Theora movies. Exporting movie to a file also uses .ogv extension.

Editor Extensibility

• New EditorWindow class lets you create a window in which you can draw custom GUI. Use it to create your own game design tools!
• Editor classes AssetImporter, TextureImporter, MeshImporter have been renamed to AssetPostprocessor. Be ready to update your asset post-processing scripts.
• Introduced OnAssignMaterial for overriding the default material assignment behaviour.
• Introduced OnPostprocessAllAssets for tracking any changes to assets from editor scripts.
• Import settings for textures and models are now exposed and can be modified from AssetPostprocessor to customize the asset import pipeline.
• Added AssetDatabase class with functions to import, delete, create Assets, and create, instantiate, update Prefabs.

Asset Server

• Server view now shows a quick summary of changes and conflicts at the top of the view.
• Improved performance of Asset Server Status and Update commands by 10x.
• Added a feature to update entire project to any previous Asset Server version.
• Reduced connection timeout from 60 to 15 seconds when connecting to the Asset Server.
• Much reduced false positives of changed Prefabs, Materials and Scripts.
• Commit message in Asset Server is now a lot faster.
• Improved displayed message when trying to commit without commit access rights.

Terrain Engine

• Multiple terrains can be included in a single scene.
• Terrains can now be moved and connected. LOD across terrain edges can be matched with Terrain.SetNeighbors.
• Terrains have an additional "Pixel Lit" render mode. Shadows on terrains finally work!
• VertexLit terrain lighting mode supports point lights now. Spot lights are treated as point lights.
• Projectors work on terrain.
• Terrain can be displayed in wireframe mode in Scene View.
• Terrain textures, tree types, and detail object types can be removed from Terrain Inspector.

Graphics & Shaders

• Added rendering with shader replacement. See Camera.RenderWithShader and Camera.SetReplacementShader – it's The Bomb :-)
• RenderTextures with high precision "depth" format can be created (see RenderTextureFormat).
• Shader Model 3.0 level shaders can be created by using #pragma target 3.0 compilation directive.
• Improved support for lightmapping inside of Unity. Each renderer now has a per-renderer offset & scale value for the lightmap and a index into a set of lightmaps available in each scene.
• Added Particle render modes for rendering particles that always face up right and particles that always lie flat down.
• Shader compiler is multithreaded, usually resulting in about 2x speedup.
• Much reduced "double lighting" artifacts on Direct3D on close or intersecting geometry when pixel lights are used!
• Re-enabled fragment programs, shadows and render-to-cubemap on Intel GMA X3100 on Mac OS X 10.5.3 and up (driver bugs got fixed).
• Upgraded Cg to version 2.0, January 2008. Improves code generation a bit and fixes some bugs.
• On graphics card with 512MB or more video memory, Unity allows higher shadowmap resolutions.
• ShaderLab: added RequireOptions=SoftVegetation pass tag, IgnoreProjector=True subshader tag, LightmapMode texture property.
• Combine Children script supports mesh vertex colors now. This requires you to reimport the Standard Assets package!
• Much improved handling of "out of video memory" situations:
  • Automatic reduction of anti-aliasing level if memory required by screen would not sanely fit into VRAM.
  • Automatic down-scaling of textures that are within hardware limits but are too large to sanely fit into free VRAM.
  • Automatic reduction of shadowmap resolution when running close to video memory limits. Fixes major slowdowns or machine hangs with large resolutions, high anti-aliasing settings, large shadowmaps and not-so-large VRAM amounts.

Networking

• Better support for limiting transmission of communication groups. Both SetSendingEnabled() and SetReceivingEnabled() now allow modification on the group level or network player level.
• Proxy relay support for clients and server. Servers can get their incoming connections relayed through a proxy server and clients can get their outgoing connections relayed as well.
• Direct relevant set support. Network views can be in or out of scope relevant to specific network players.
• NetworkViewID can now be serialized during state synchronization.

Scripting

Animation & Skinning:

• Added API to procedurally generate animated characters, stitch multiple character pieces into one character at runtime to reduce draw calls, or reassign bones to different characters.
• Added API for creating Animation Events that are invoked when the animation clip is played back and passes the specified time. You can now easily spawn particles, play sounds and so on, all synced to animation.
• Individual Animation Curves can be created from scripts and used as response curves.
• Material properties can now be animated using animation clips. Any material property including UV tiling, UV rotation, float properties, Color properties and Vectors can be animated using Animation Clips.
• Editor API for accessing AnimationClip curves, animation states and sampling the current state of a specific animated property of any scene object.
• You can assign animation curves to animation clips.
• Renamed AnimationCurve's preInfinity, postInfinity to preWrapMode, postWrapMode.

Graphics:

• Added Graphics.DrawMesh that draws a model, while taking all lighting, shadowing, projectors and whatnot into account.
• Renamed Graphics.DrawMesh to Graphics.DrawMeshNow. Graphics.DrawMesh does other things now…
• Exposed Light's shadowStrength, shadowConstantBias, shadowObjectSizeBias properties to scripting.
• Added Texture2D.LoadImage(byte[]) function to load a JPG or PNG from a byte array.
• Shader.name now returns the actual name of the shader (same as used in Shader.Find), not the filename.

Other:

• Added Application.LoadLevelAdditive. Incredibly useful for creating continous virtual worlds, where more content is loaded as you walk through the environment.
• Seeking in played sounds via AudioSource.time!
• JavaScript now supports virtual keyword!
• System.Environment.CommandLine and System.Environment.GetCommandLineArgs() works in editor and standalone players.
• Added TextAsset.bytes.
• GetComponent now works correctly with abstract classes and interfaces.
• WWW files can now be cancelled while they are downloading.
• Input.GetKey API now supports Keycode enum instead of string based queries for improved performance.
• 50% faster GetComponent or component accessors. Heavily reduced memory allocations which reduces strain on the garbage collector, further improving speed.
• A warning is given in the editor when user script has the same name as a built-in Unity component.
• Added warning when creating MonoBehaviour from code incorrectly using the new keyword.

Other improvements

• Multiple Audio Sources can now be added to a single Game Object.
• Standalone Windows games can use arbitrarily sized windowed resolutions (window sizes no longer limited to list of display resolutions).
• ShaderLab reference moved from Manual into Reference. Much expanded documentation regarding Cg shader programs.
• Improved performance for animation sampling with deep hierarchies where not all transforms are animated.
• On OS X, Unity won't print to global system console anymore. Editor prints to ~/Library/Logs/Unity/Editor.log, and players print to ~/Library/Logs/Unity/Player.log (both can be viewed through Console.app, or opened from Unity's Help menu).
• Improved performance when downloading large WWW files.
• PlayerPrefs are now stored in the same place as the published standalone player and not in the Unity Editor preferences file.

Bug Fixes

Graphics Fixes

• Worked around wrong GUITextures and UnityGUI rendering on ATI Rage cards on Windows (buggy drivers).
• Transparent/Cutout shaders did not take material color's alpha into account when casting shadows.
• Loading grayscale JPG images via Texture2D.LoadImage, WWW.LoadImageIntoTexture and WWW.texture works properly now.
• Particle Renderer now takes "stretched particles" mode into account when computing particle bounds (no more false culling of stretched particles).
• GUITexture Border values work properly when non power of two RenderTexture is used with it.
• GLSL shader compilation errors are properly reported in the editor.
• Particles/Additive (Soft) and Particles/Multiply (Double) shaders now work correctly on some old cards (e.g. Radeon 7000).
• Camera.Render will synchronize renderer bounds if they have been moved in between Render calls or when using the function from Editor scripts.
• Fixed shadows not visible from a directional light when all shadow casters are outside the view frustum.
• Fixed mesh bounds sometimes not being applied correctly if a mesh is modifed from Awake() or Start() functions.
• Fixed streaming movie textures not filling object surface correctly if Play() is called after assigning texture to the material.
• Fixed issue where bounding volumes were calculated incorrectly for skinned characters. This has affected lighting and affected frame selected being off when selecting characters.
• Flares work properly when their texture is a RenderTexture.
• Fixed a bug when non power of two RenderTextures were used with GUITexture (sometimes only top-left pixel was visible).
• Fixed "offset != skin.inStride" error message when a skinned mesh uses a shader that requires vertex colors, but the mesh does not have them.
• Fixed "Unhandled vertex structure for strided buffers" error message if shader required (position, normal, color, tangent) vertex data.
• Fixed renderer.bounds being wrong on skinned meshes when called before rendering them for the first time.
• Fixed GL.Begin/GL.End on Direct3D in some cases disabling TexGen mode of objects that are rendered later.
• If a vertex or pixel shader on Direct3D fails to load, only current subshader is disabled, and not whole shader.
• Fixed bug where multiple skinned mesh renderer on one animated characters would incorrectly disable the animation when one of them became invisible.
• Fixed crash when no skinnable mesh is assigned to a skinned mesh renderer.
• Fixed crash on Vista with some Intel graphics cards when mesh does not have vertex colors but a vertex shader requires them.
• Fixed crash when shader's UsePass command contains malformed shader/pass name.

Web Player Fixes

• Windows Web Player on Internet Explorer will send cookies with POST requests now.
• WWW class on Internet Explorer would sometimes fail downloading when the web server was serving gzip-compressed output. Fixed.
• Internet Explorer would always indicate that web player data files are still downloading (status bar & spinning IE logo), even after they finished downloading. Fixed!
• System.Socket using Async callbacks now works correctly in the web player.
• When web player data file is corrupted, proper error is shown on Windows Web Player.
• When running web player under Rosetta on OS X it now gives an error message detailing that you must not run in Rosetta mode.
• Fixed crash in LoadUnityWebStream.
• Fixed web player games not starting properly on some ATI Rage drivers on Windows.
• Fixed Windows Web Player not resizing properly on non-IE browsers when plugin area is resized (e.g. having percentage CSS width).
• Fixed Dashboard widgets not handling active state properly on OS X Leopard (e.g. music would still play when Dashboard is hidden).
• Fixed Web Player auto-update on Windows when Program Files and Temp folders are on different drives.

Editor Fixes

• Editor scripts no longer have MonoBehaviour default references, this makes wizards no longer have default references. It is necessary because otherwise some scriptable object based editor functionality would behave incorreclty with the automatically generated ScriptableObjects.
• Abstract classes can not be added as components anymore.
• Prefabs containing MonoBehaviours no longer cause the prefab to reimport without the user actually changing it.
• Ogg Vorbis encoding rate is clamped to allowed range by the encoder (the range depends on input channel count and sample rate).
• Ogg Vorbis and Theora encoding errors are actually shown in the editor, instead of being printed to system console only.
• User script named CopyTransform could not be added using AddComponent or accessed via GetComponent.
• Fixed import of animation clips when loop frame is enabled. Unity will now match the tangents at each end to flow into each other smoothly.
• Fixed Movie importer failing for some very short (several frames) movies, or dropping a couple of last frames on those movies.
• Fixed Game View Statistics window reporting incorrect size of used textures when global texture resolution is reduced via QualitySettings.
• Fixed objects using non-standard fog mode (e.g. linear) appearing black in scene view.
• Fixed Characters option being initially empty in font import settings dialog.
• Fixed Scene View only showing first 16 defined layers by default.
• Fixed a bug where references from a script components inside of a prefab in some rare cases could get reset to null.
• Fixed a bug where encoding an audio file that had zero size video data failed importing as an Ogg Vorbis file.
• Fixed memory leak in audio importer and movie importer.
• Fixed bug where adding a script to an import model would automatically clear references to objects inside the prefab.
• Fixed GameObject.SampleAnimation and editor's Timeline view when boolean (on/off) properties were animated.
• Fixed various serialization crashes: arrays of enums, arrays of structs in some cases, arrays with non-Object derived classes that also contain an Animation State.
• Fixed crash when importing a model that has out of bounds material indices.
• Fixed crash when undoing an import of a RAW file heightmap.

UnityGUI Fixes

• When GUILayout gets confused it just complains but does not crash :)
• Wordwrapping fixes – especially showed up when single-character words would get clipped.
• Start() now gets called before OnGUI().
• Scroll bars no longer break keyboard focus.
• GUI.Window supports having a tooltip for the window itself.
• GUI.DrawTexture fixes.
• GUI.BeginArea can now be called conditionally.
• Fixed RotateAroundPivot & ScaleAroundPivot.
• Fixed mouse tracking when nesting scroll views.
• Fixed mouse-over not working properly after dragging a ScrollView inside a BeginGroup.
• Scrollbar fixes: up and down button sizes no longer swapped in vertical scrollbars, clicking left arrow no longer hides right arrow.
• GUILayout.BeginScrollView now correctly handles fixed width & height using GUILayout.Width.
• GUI.Window does not always set GUI.changed to true
• Moved text 1 pixel left so it stays inside the buttons.
• Scaled GUI no longer gets clipped to the original top-left of the screen.

Networking Fixes

• Fixed Network.SetSendingEnabled() where it was sometimes not possible to reset a communication group.
• Broadcast RPCs no longer include newly disconnected players, which was harmless but resulted in errors in the debug log, for example when sending broadcast RPC inside OnPlayerDisconnected().
• Fixed marshalling of BitStream.Serialize for booleans.
• Fixed a bug where the external IP address would be reversed on PPC machines which are connected to Intel machines.
• Fixed a bug where the external IP address contained a garbage value.

Physics Fixes

• WorldParticleCollider now works properly with Terrain and Sphere colliders.
• Fixed Joint issue on PowerPC Macs in some ragdoll configurations.
• Fixed a crash when calling CharacterController.Move on an inactive controller.

Audio Fixes

• Fixed Play On Awake setting being ignored for AudioSources that are added dynamically from script (audio was always playing).
• Fixed Movie audio not playing on Windows when calling Play(), if the audio source had Play On Awake set.
• Fixed crash on Mac OS X when setting audio source pitch to extreme values (now pitch is clamped to 0.1 .. 10.0 range).

Terrain Engine Fixes

• Terrain Lightmapper shadow anti-aliasing now actually works properly with more than 4 samples
• Tree placement width & height variation sliders are no longer locked together.
• Fixed terrains leaking memory when they are used with reflective Water and water gets disabled.
• Fixed terrain not being visible on new machines if game was built on old machine (e.g. Mac with Rage card).
• Fix crashes when painting details on terrain that has invalid detail resolution. Also prevent from setting invalid detail resolution in the Set Resolution wizard.

Asset Server Fixes

• The Asset Server client will now skip deleting directories that have been deleted on the server but still contain uncommitted changes locally.
• The Asset Server administration interface does not allow creating new users with invalid characters in the user name.
• Unity no longer attempts to contact the Asset Server during startup until it is completely finished launching the application.
• Asset Server does not allow discarding changes from manager objects that are not on the server.
• Fixed infinite loop bug that could happen in rare cases when updating from or committing changes to the Asset Server.

Other Fixes

• Quaternion equality and inequality operators actually do something meaningful now :-)
• Using yield to wait for a WWW download to finish will now also work when Time.timeScale is zero.
• Fixed float.Parse() in some rare cases returning NaN results on Windows.
• Fixed LookAt sometimes reporting that a rotation is not valid.
• Closing screen selector via red close button on OS X would still launch the game. Fixed!
• Fixed some scripts not running properly when Windows Data Execution Prevention (DEP) feature is on.
• Fixed OnEnable() and Start() still called on a script that is disabled from inside of Awake().
• Fixed bug on OS X, where some Logitech keyboards would not register any input because they don't support HID. Unity now automatically falls back to a Carbon based solution if HID keyboard input is not supported by the device.
• Fixed crash when setting fixed timestep to zero.

Unity 2.0

Note: a newer version of Unity has been released since Unity 2.0. Check out the current release notes to find out what's really new.

We have been hard at work for over two years, and are now proud to present Unity 2.0: the largest and most exciting update to Unity and the Unity Web Player that has ever been released. The 50+ new features all make your games look better on more platforms, run faster, and easier to make.

Terrain Engine

To support highly detailed and massively big worlds, we bring you a highly optimized terrain engine. Import a heightmap image, or create one yourself, using the built-in brushes and other terrain editing tools. Push, pull, or paint the height of the landscape. Draw and combine multiple terrain textures for hand-built roads or foot-worn wilderness paths.

Hundreds of thousands of trees can be rendered real-time with Soft Directional Ambient Occlusion shaders. Grass and detail objects in the billions are generated on the fly around the player. Hand-place trees, rocks, grass, flowers, or any other decoration with the new tools. The terrain can even be deformed and modified at runtime for dynamic gameplay mechanics.

Video Playback

Unity is a strong media platform on its own, and so in Unity 2.0 games can include video as well as audio. Videos can be played back in 2D or 3D just like audio, and can also be wrapped around objects in the 3D space. And of course you can play back an audio soundtrack syncronously with the video.

As part of our commitment to streaming, you can either include the data files in the game or stream them directly from the web.

Video playback is a Unity Pro-only feature.

DirectX 9.0 Renderer

Standalone games and the Unity Web Player now take advantage of native DirectX libraries on Windows. Considering that DirectX is much more widely-supported on Windows, this means that your games will run faster and more reliably now.

To ensure that Unity is stable and fast everywhere we set up a testing lab with a large number of computers. In the lab we extensively tested for compatibility on hundreds of graphics cards and driver combinations.

Across the board, you can expect a doubling in the frame-rate from previous versions, and greatly increased stability on the oldest of old graphics card drivers.

Networked Multiplayer Games

The easy to use yet highly optimized Networking layer makes it a breeze to create great networked multiplayer games. The Networking Layer is completely based on UDP, provides NAT punchthrough, and has support for sending packets reliably and unreliably. Unity's new Network Views support the two methods of network communication: State Synchronization and Remote Procedure Calls.

A library of re-usable networking scripts takes the hard work out of understanding networking concepts, so you can get started creating scalable multiplayer functionality quickly and easily.

Real-Time Dynamic Shadows

Shadows in Unity 2.0 are dynamic, optimized, and allow self-shadowing. All light types can be instructed to cast shadows – Pointlights, Directional lights, and Spotlights. Even alpha-textured objects cast shadows correctly!

A wide range of options let you specify which objects receive and cast shadows, so you can tweak your world for high performance and the perfect look.

Shadows are a Unity Pro-only feature.

Game GUIs

Unity's GUI system has undergone a complete overhaul, and in Unity 2.0 we bring you a fast and efficient way of creating GUIs for your games. Not only is the new system robust with dozens of GUI object types – including buttons and text labels – it can also all be skinned.

If you're familiar with CSS, you'll feel right at home with skinning Unity GUIs. Adding functionality to your GUI objects is simpler and more intuitive as well – we're talking "single line of code" easy.

Web Player Streaming and Compression

On the web instant startup times are crucial. To make this easier to achieve, Unity 2.0 features a new streaming Unity Web Player, which organizes assets by level and downloads them in order. Thus, your game will start immediately after assets in the first level have finished loading. If you have multiple levels, they will finish downloading silently in the background while the game is being played.

Additionally, state of the art LZMA compression reduces file size by a solid 30% compared to earlier version, and the game is decompressed on the fly. This means that even your first level can finish loading in seconds. The best part is that Unity will do all this for you automatically, with zero setup. It's invisible to you, and it's invisible to the player. You can rest safely in the knowledge that your deployed games will load on the player's machine faster than ever before.

Unity Asset Server

The Unity Asset Server is a full version control solution for game assets and scripts. Like everything else in Unity, it's polished and simple to use. Multi-gigabyte projects with thousands of multi-megabyte files are handled with grace. Import settings and other metadata are stored and versioned too. Updates, commits, and graphical version comparisons are all done inside the Unity editor. When files are modified, their status instantly updates visually. Renaming, moving, and restoring assets is handled elegantly.

The enterprise-level database PostgreSQL powers the Unity Asset Server. PostgreSQL is famous for reliability, data integrity, and easy administration. PostgreSQL handles the workloads of huge projects. The Asset Server is available both as a Mac OS X Installer and as Linux RPMs. The support for multiple platforms gives you flexibility in how to integrate the Unity Asset Server into your existing IT infrastructure.

The Unity Assset is an add-on product for Unity Pro only.

More Major Features

We've been working on Unity 2.0 for over two years now, so of course there's lots more in there. And of course there's hundreds of minor improvements and bug fixes and driver workarounds too.

Web Player

• The Unity Web Player installation process has been greatly simplified. No browser restarts are required on any browser, no windows are popped up to download the installer, and content starts as soon as the installer is finished.
• Unity web files can now be streamed. Assets are automatically reordered in the stream by the first level that uses them. This is an amazing no-hassle way of streaming web players. Unity essentially does everything for you. In your scripts you simply have to query if the level you are about to load has already been downloaded completely. By ensuring your first few levels are not using a lot of assets, you can start your game with only a minimal amount of data.
• Web Players data file compresses around 30% better now. Unity now uses the state of the art LZMA compression algorithm. Data files are decompressed on the fly, resulting in shorter load times. We also use solid compression – multiple game levels share the same compression dictionary, this further increases compression ratio.
• You can now switch to fullscreen in web player from a script. The same rules as for mouse locking apply: user must have clicked on the content before you can go fullscreen.
• Safari 3 for Windows support as added.
• Web players on Windows properly pause when browser is in background.
• Web player progress loading images can now be .pngs with an alpha channel.
• Added disableContextMenu, disableFullscreen and disableExternalCall embed tags.
• On Windows, the Unity Web Player can now perform auto-update on non-admin user accounts.
• Unity and Unity Web Player installers on Mac OS X will now cleanup receipt files in order to work around Apple's installer limitation of not allowing installations of older versions.
• Made a new CLSID for the Internet Explorer plugin, and new plugin name for Netscape-like browsers.
• Changed default web player installation path on Windows to [program files]\Unity\WebPlayer.
• Added a WWW.url property.

Workflow

• Automatic Ogg Vorbis audio converter. Optionally force Stereo or Mono for positional sounds, choose compression and preloading settings. MP3 files are automatically converted to Ogg Vorbis by default.
• Imported Ogg files (audio and video) can be exported via a menu command in the Assets Menu for web streaming.
• Graphics Card Emulation. You can now simulate older graphics cards from a menu item (Edit > Graphics Emulation). This is extremely convenient to quickly preview how your game looks on that graphics card without different hardware.
• Texture Atlas generation function added as Texture2D.PackTextures(). Combine multiple textures into a single texture. This is useful for optimizing graphics performance when combining objects which might not otherwise use the same texture.
• Imported Models can now be post-processed during import. Once the basic importing of a model is complete, MeshImporter.OnPostprocessAsset() will be called. From here you can modify all meshes, GameObjects, Components, etc. to your liking. This allows you to completely customize the asset pipeline. Trees in the Terrain Engine take advantage of this. See the MeshImporter class for details.
• Textures can be postprocessed in the same way. For example you could invert the colors of an image. Or ensure that normals of a normalmap are always normalized even in the mip levels.
• 16 more layers have been made available. This is useful for people who have run out of layers to use.

Unity Editor

• The Unity Editor has received a complete facelift! New skin, new buttons, new icons, new gizmos. Reimport your existing Unity 1.x project to see the new asset icons.
• Optimized drawing of editor views; editor is much faster with complex projects.
• Progress bar in the editor for building players and Terrain lightmapping.
• New Directional light gizmo.
• Integer values can now be right click dragged in the Inspector.
• Rectangles are now defined as x, y, width, height matching the way they are used in scripting.
• Pipeline components are not used anymore. You can remove them from your existing objects if they bother you :)
• Rects, Vector2 and Vector4 can now be serialized in the inspector for scripts.
• Serialization of arrays in scripts has been greatly optimized.

Rendering

• Rendering system rewritten! A new render pass sorting algorithm is used. Passes are sorted to minimize state changes. The algorithm takes lights and shadows into account. We've seen up to 50% speed increase on real world scenes!
• Lights have an intensity property. The intensity can be up to 8. This can be used to create very strong lights even if they have a small light range.
• Skinned Mesh Rendering has been optimized. It is 2-4x faster than in Unity 1.6.2!
• Lighting from Point lights is much less "blocky" on fragment program capable cards.
• Vertex lights now match pixel lighting more closely.
• Specular highlights in builtin shaders are less attenuated now.
• Orthographic cameras sort transparent objects by distance along their Z axis, which makes 2D games easier!
• Switching materials from inside OnPreRender/OnPostRender works as expected now. This is useful if you want specific cameras to render with specific materials.
• Cameras can now be removed or added during any time. Even while drawing/culling another camera.
• Improved appearance of Particle Additive, Additive-Multiply and Alpha Blended shaders. If some of your particle objects became too bright, make the tint color 2x darker. The change was needed to make particle appearance match in D3D and OpenGL.
• Changed the order in which cameras are culled & rendered. Before it was like this: CullAllCameras(); RenderAllCameras();. Now the order is per-camera: for( all cameras ) { CullCamera(); RenderCamera(); }. The change should not affect you, but it's now easier to use OnPreRender and friends.
• Default near clip plane for cameras increased to 0.3. Yay for better depth precision!
• Added Texture2D.GetPixelBilinear() function.
• Added Graphics.DrawTexture().
• All render textures on Mac OS X use OpenGL "frame buffer objects" if available. This makes render textures generally faster.
• Added Camera.RenderToCubemap for dynamic cubemap reflections.
• Added Material.HasProperty() function.
• Render Textures can now use mip maps (mip levels are automatically generated).
• Textures can now be reinitialized using Texture2D.Resize().
• Texture2D.ReadPixels() has been added. This has many cool applications.
• Reading pixels from Texture2D has been optimized.
• The normal smoothing angle is now also used as a smoothing angle for tangents. This allows for adjusting tangents so that tangent issues with generated normal maps are fixed. For example, this makes normal mapped characters have a lot less seams.

Physics

• Convex Mesh Colliders can automatically be generated from any Mesh, by checking the convex flag. Convex Mesh Colliders can collide with any other Collider.
• Added Configurable Joint. A highly configurable joint with direct control over all 6 axes, including soft limits. This joint can do just about everything.
• Added Heightmap Collider.
• Ageia PhysX has been updated to version 2.6.2.
• 10x performance optimization when loading collision meshes.
• Optimized performance of raycasting on PowerPC Macs.
• Support for cone friction – a more accurate friction implementation. This can be enabled via scripting.
• Performance for kinematic rigidibodies that are being moved around a lot has been greatly improved.
• Default values for Hinge Joint are now more intuitive.
• Ignore collision now also works between two character controllers. Added CharacterController.disableCollision.
• Slope limit and step offset exposed to scripting in CharacterController.
• RaycastHit now contains a barycentric coordinate member that can be used to interpolate vertex attributes in the triangle, ie. smoothed normals.
• The animation system can now apply friction and velocity correctly to kinematic rigidbodies. This allows you to animate platforms and stack boxes or other rigidbodies on top. To enable it you have to make the rigidbody kinematic and turn on Animation.animatePhysics.
• MovePosition()/MoveRotation() has been added to the rigidbody class, it is useful for animating kinematic rigid bodies so that they apply friction correctly to touching objects.

Scripting

• Support for .NET 2.0 including generics!
• Full support for eval in JavaScript!
• Added OnJointBreak() callback when a joint is broken by joint break force.
• Static variables are now automatically reset when hitting Play.
• ExecuteInEditMode attribute will make scripts will run in edit mode. This is useful if you want to interact with the editor, for example to see your changes live without entering playmode.
• WWW class can now perform POST requests in addition to GET requests.
• WWW class can load PNG images in addition to JPG images.
• WWW class can read local files using WWW("file://mypathname"). This is disabled in the Unity Web Player.
• Added WWWForm for easy uploading of forms.
• Arrays of classes marked are now be shown in the inspector and are serialized. You simply have to give the class the Serializable attribute.
• Added Texture2D.EncodeToPNG().
• Added on WaitForFrameComplete() coroutine. This will execute after all rendering is done. Useful for grabbing screenshot and posting to a web server for example.
• TextAsset class has been exposed to scripting. This lets you easily use text files without having to go through .NET file routines.
• Added Application.unityVersion.
• Moved Graphics.deviceName and friends into SystemInfo class.
• Added Matrix4x4.Perspective for constructing perspective matrices.
• Coroutines can now take an arbitrary amount of parameters.
• Creating game objects has been streamlined. You can pass in an optional argument list with several components to automatically add them.
• Added CloneComponent() function. This is useful for copying individual Components to a different game object.
• Added Debug.LogError() and Debug.LogWarning() functions.
• Optimized Vector3 math functions.
• HideInInspector attribute added.
• When instancing a material or physics material, "(Instance)" will be appended to it's name. This lets you easily differentiate shared materials and instanced materials.
• OnEnable() and OnDisable() has been added for ScriptableObject().
• The seed of a random number generator can now be set from code.
• Animation.RemoveClip() has been added. This is useful for reducing the set of textures in order to improve performance.
• HideFlags can be used to specify what is visible in the hierarchy, project view and inspector. You can also use this to make Unity not store an object in a scene.
• Mathf.Abs() is now also available in an integer version.
• Renamed Camera.orthoGraphic to Camera.orthographic.
• Removed Texture2D.frameCount and Texture2D.frame properties. Use arrays of textures and switch them manually.
• Changed Camera.WorldToScreenPoint(), Camera.ScreenToWorldPoint() and similar functions to use world space depth in Z component, instead of non-linear z-buffer depth.
• Added DXT1 and DXT5 texture formats for scripting.

Shaders

• GLSL is supported as shader language in addition to Cg.
• Lots of render queues for shaders! If you want to make something render after opaque things but before transparent things, now you can. See Tags documentation in ShaderLab docs.
• Comment-style directives for compilation are replaced with more robust and intuitive #pragma directives.
• Cg compiler updated to Cg 1.5. Shader compilation is much faster due to new batch Cg importer and because Cg 1.5 is Universal Binary.
• Shaders use #pragma multi_compile tags instead of autolight codes to generate different variants for different light/shadow types.
• Added AlphaToMask command to ShaderLab (still waiting for Apple to properly implement it in Mac OS X; but it works on Windows now).
• Writing dummy SetTexture {} commands after fragment programs is not necessary anymore.
• Renamed some builtin shaders: Alpha -> Transparent, Glossy -> Specular, moved Parallax shaders into corresponding groups.
• Shaders that contain errors are put into separate submenu in material inspector.
• Added Shader.SetGlobalVector().
• Shader.Find() always returns user made shaders if there is also a builtin shader with the same name.

Water in Unity Pro

• It works correctly in Scene View! It also just works with multiple in-game cameras.
• Much improved setup. Just a single script (Water.cs) and a single material to use. Switch between Simple, Reflective and Refractive in the Water script in the Inspector.
• Best way to upgrade is 1) delete Standard Assets/Water and Pro Standard Assets/Water folders, 2) reimport Standard Assets and Pro Standard Assets packages.

Unity 2.0.1

Unity 2.0.1 was a quick update we released to be able to support Mac OS X 10.5 "Leopard".

• Fixed editor crash on Mac OS X Leopard whenever color property was in the Inspector.
• Fixed 'F' key focusing not working on Leopard.
• Fixed Layer popup in GameObject inspector on Leopard.
• Fix double click not launching asset editor on Leopard.
• Disabled mipmapped render textures on GeForce 8600 on Leopard and Tiger (an OpenGL driver bug which leaks memory is not fixed yet).
• Fixed some broken links in the documentation.

Unity 2.0.2

Counting in bugfixes and optimizations, Unity 2.0.2 is a huge release. But we added a few features and improvements too, mainly focusing on the new features that got introduced in Unity 2.0.

Networking Improvements

• A new integrated Ping class for pinging remote servers or machines.
• Added boolean and byte array parameter support for RPC functions.
• Improved host list processing (Network.RequestHostList()) so it doesn't cause delays. Client connections to the master server are also more efficient.
• A function which provides local NetworkPlayer information. Provides local IP address, internal and external with NAT addresses (after connecting to a remote machine).
• Added compare operators on NetworkPlayer and NetworkViewID structures.

UnityGUI Improvements

• Copy & Paste now work in UnityGUI through CMD-C/CMD-V (Mac OS X) and CTLR-C/CTRL-V (Windows) keys.
• Added GUIUtility.RotateAroundPivot(), GUIUtility.ScaleAroundPivot(). Guess what they'll do to your GUI :)
• Improved GUILayout.ScrollView's logic for detecting when scrollbars are neccessary.
• Made the default GUI skin a bit brighter so it looks better on Windows boxes, and other minor tweaks.
• TextFields now select their content when the user tabs to them.
• EventType enum members were made UpperCase (so EventType.repaint becomes EventType.Repaint). Old scripts will continue to work, but warnings are generated when they compile.

Graphics Improvements

• Improved skinning performance on OpenGL by about 20%. It's about as fast as D3D now :)
• Texture2D.PackTextures creates a DXT compressed texture atlas if all input textures are compressed.
• As a result, video memory usage in terrain engine is decreased when you're using compressed textures.
• Two UV sets are now correctly imported from 3DS Max when using Standard material types, making lightmaps easier to get across.
• Removed hardware depth buffer bias for shadows in OpenGL. This can make shadow bias slightly worse, but matches Direct3D behaviour (less unpleasant surprises).
• Improved error message when assigning DXT compressed lightmap to the terrain.

Other Improvements

• Application.runInBackground now suppored in the web player.
• Improved file size info reporting when building games. Unity now prints the size taken up by each asset and sorts all assets that are used in the build by size.
• Windows standalone build startup dialog has input configuration just like Mac OS X standalone!
• Added WWW.uploadProgres to track progress of large file uploads using the WWW class.
• Unitron text editor accepts files dropped on it via Dock, can be used as an "Open As" in the Finder & got a new application icon.
• When using the Unity Asset Server, the current project name and server is now shown in the main window title bar.
• Added EditorUtility.SetDirty() function to notify changes in scripts performed from editor scripts.
• Support for Reproduction Logging on standalone Mac OS X games. Hold down CMD-ALT-CTRL while loading the standalone player and Unity will ask you to write or read from a log file. This records all input and lets you play it back in order to easily reproduce a crash or other issue.

Graphics Fixes

• Fixed a bug in Trail Renderer where trails would not appear again if object had been disabled or stopped moving.
• Fixed a bug where shadow receiving objects and terrain engine billboards were rendered in incorrect order.
• Fixed GL.Viewport() on Direct3D when render texture is active at the time of the call.
• Fixed winding order of GL.QUADS under Direct3D.
• Fixed issue in Windows games where exiting fullscreen mode could fail if desktop is 16 bit color depth and the card does not support 32 bit backbuffer with 16 bit display mode (S3 Savage, Matrox G 200/400/450 and the like).
• Fixed GUI rendering on Direct3D on S3 Savage4 and Matrox G 200/400/450 cards.
• Disable render textures on S3 Savage4/ProSavage cards on Windows (their drivers tend to crash otherwise).
• Fixed rare problems on GeForce 2/4MX cards on drivers that advertise support for vertex shaders (though the hardware does not support them).
• Fixed Mac OS X kernel panic when creating render texture that is larger than the maximum render texture size.
• Driver workarounds for Intel GMA X3100 card in new MacBooks on Mac OS X:
  • Disable shadows (produces random garbage or crashes).
  • Disable fragment programs (very often computes wrong results).
  • Disable render to cubemap (produces random garbage).
  • Grass billboards in terrain don't wave in the wind (otherwise it transforms vertices incorrectly).
  • Non-fullscreen cameras don't clip their rendered contents; did not find a workaround yet.
  • ...all hail Apple!
• Water reflections/refractions work correctly with orthographic cameras. Update Pro Standard Assets!
• Fixed WWW PNG file loader to be more correct when using palettized images.
• Scaled trees in the terrain engine will now be correctly culled when rendered as billboard meshes.
• Fixed particle system bounds not updating properly when assigning whole particle array from script.
• Fixed particle emitter velocity scale behaving erroneously when Time.timeScale is small or the amount of particles emitted per frame is low.
• Fixed a bug where some shaders would not be properly included in built players (e.g. Refractive Glass Specular, or Toon Outline). Reimport those shaders and rebuild your game.
• Fixed SystemInfo.graphicsMemorySize detection under Windows Vista.
• GL class immediate mode rendering can handle very large amounts of primitives on Direct3D now (previously was limited to 4096 vertices per Begin/End call).
• Fixed Screen.currentResolution initially returning wrong result on Windows Web Player.
• Fixed terrain engine tree impostors sometimes getting noise or lines at billboard edges.
• Fixed non-power-of-two GUI textures that don't have mipmaps displayed slightly wrong when using global texture resolution in Quality Settings.
• Fixed Camera.RenderToCubemap some faces being flipped on Direct3D when rendering into a static cubemap.
• Fixed first frame on Mac OS X web games sometimes showing garbage.
• Fixed bug in terrain renderer where base map rendering kicked in too early.
• CaptureScreenshot() and ReadPixels() work correctly in Direct3D when display mode is 15 or 16 bit color.
• On Intel 845/865 cards on Windows clamp maximum render texture size to 512 on drivers older than January 2004 (buggy drivers).
• Fixed shader compiler crashing on PowerPC machines in some situations (for example the Island Demo water shader).
• Fixed crash when calling Texture2D.PackTexture() function on a null texture.
• Fixed crashes in Direct3D on graphics cards that don't support 32 bit textures (Intel 810 card).
• Fixed a bug where creating a Texture from a static constructor would crash Unity.
• Fixed rare crashes on Windows when toggling fullscreen mode (mostly happened when skinned meshes were used).
• Fixed standalone player crash on Direct3D when the graphics card does not support 32 bit color depth resolutions.

UnityGUI Fixes

• CMD-A (on Mac OS X) & CTRL-A (on Windows) selects all text in text fields and text areas.
• TextFields now handle maximum string length correctly.
• TextFields got more correct double-click behaviour (for example double-click now properly selects words on Windows).
• GUI controls now let go of captured mouse properly.
• GUI ToolTips flicker less.
• GUI.DrawTexture() correctly handles GUI.color and GUI.contentColor.
• GUI.DrawTexture() works correctly for ExecuteInEditMode scripts.
• GUI.Toggle now has the text placed on the same baseline as Label and Button.
• Text cursor is now correctly clipped to windows and scroll views.
• Tab key correctly cycles keyboard focus between multiple scripts.
• GUILayout.Space no longer uncollapses margins on surrounding elements.
• GUILayout.Space no longer breaks sizing calculations.
• Calling GUI.* or GUILayout.* functions now throws an exception if you try to do it outside OnGUI() code.
• Fixed OnMouseEnter() / OnMouseExit() / OnMouseDown() and friends when GameObjects go behind new-style GUI.
• Tab character for UnityGUI navigation on Windows does not insert extra tab characters into text fields.
• Fixed arrows, HOME, END and TAB keys not getting into UnityGUI on Windows Web Player in Internet Explorer.
• GUILayout.BeginVertical() and BeginHorizontal() now correctly handle mouse-over GUIStyleStates.
• Fixed small bug with GUI.enabled and button presses.
• Fixed FlexibleSpace not working correctly with MinWidth and MinHeight options.
• On Windows GUI is properly drawn when game is paused because it is in background.
• GUI.SelectionGrid and GUI.Toolbar has correct mouse tracking (could get off by some pixels in some cases).
• Double clicks in the Mac OS X web player now correctly select text in TextFields.
• GUILayout.BeginArea and GUI.BeginGroup now draws background style correctly.
• GUI.Matrix no longer blocks mouse events when controls have been moved.
• Margins between GUI groups no longer get doubled if they are inside a scrollview with a visible scrollbar.
• Custom GUI style names will now be maintained instead of automatically being lower cased.
• GUI ID generation improved. You can now rename GUI groups without mucking up controls inside them.
• Fixed GUILayout sizing calculations for images in GUIContent with wordwrapped text.
• Fixed GUILayout.MaxWidth and GUILayout.MaxHeight overrides when non-wordwrapping elements contain too large images.
• Fixed bug where Event.current.delta in mouse drag events always returned zero on Windows.

Web Player Fixes

• Joystick and gamepad buttons work correctly in Windows web player.
• Fixed WWW downloads not finishing if they are completely in Internet Explorer's cache.
• WWW POST request fixes on Internet Explorer: now works when using some GET parameters, when connecting to non-default server port, and don't report error when server returns HTTP redirect status codes.
• Fixed WWW audio streaming crash that would sometimes happen on Internet Explorer.
• Fixed issue where running in fullscreen mode on Mac OS X web player would sometimes crash after a few minutes.
• On Internet Explorer ExternalCall(), ExternalEval(), OpenURL() are now executed in the frame/iframe, and not the topmost window. This matches behaviour of other browsers.
• Fixed issue where Windows Web Player content on Firefox and Safari would make some JavaScript libraries (like script.aculo.us or Dojo Toolkit) not work correctly.
• Fixed issue where switching fullscreen in Safari 3 would sometimes toggle between fullscreen and window mode in erratic ways.
• Fixed issue where Mac OS X web player on Safari would sometimes exit fullscreen mode automatically.
• Fixed mouse lock not working in Mac OS X Dashboard Widgets.
• Fixed crash during install process of web player from Mac OS X Dashboard Widget.
• Progress bar in web player on Firefox now updates more responsively.

Networking Fixes

• Fixed two bugs relating to InitializeServer() resetting stuff it shouldn't. InitializeSecurity() now actually works , and incomingPassword works when used before InitializeServer().
• Fixed problem where connection tester IP and port were unchangeable after one test run.
• Fixed bug which caused the server password to get lost during password connects with arrays of IPs.
• Fixed problem where network view IDs would be reused when the owning network view was disabled in the editor.
• Fixed Windows crash when accessing NetworkView.owner.
• Fixed problem with Network.minimumAllocatableViewIDs not being set correctly.
• Fixed problem where a prefab could contain a scene ViewID and conflict with another scene View ID when instantiated.
• Handle the case properly when Network.DestroyPlayerObjects() is called by a client. It doesn't assert anymore and the client can destroy its own players objects.
• Fixed crash when using null strings as game type in the MasterServer class functions.

Physics Fixes

• Renamed Physics.bounceTreshold to Physics.bounceThreshold (the old property is still around for backwards compatibility).
• Fixed bug in Bounds.IntersectRay() function.
• Fixed bug where Unity would sometimes perform physics incorrectly on instantiated prefabs containing a lot of joints.
• Fixed crash when physics simulation contains NaN values.
• Fixed a bug where animation system would sometimes introduce NaN's into transforms, leading to a crash in PhysX.
• Fixed crash when setting axis or anchor on an invalid joint.
• Rigidbody extrapolation now works correctly again.

Other Fixes

• Fixed jerkiness in Windows games running on a computer that had not been rebooted for a couple of weeks.
• Fixed comparing, reverting and restoring files from the Asset Server that contained a resource fork on Leopard.
• Fixed WWW.progress to return 0.0 instead of NaN in some cases in the standalone player and the editor.
• JavaScript eval() now works correctly in standalone games.
• Streaming progress function now returns false if the level is not included in the build.
• Improved assertions when user enters NaN values into Unity.
• Fixed issue where NaN value assert would show up in the editor when maximizing game view on PPC machines.
• Fixed crash when dragging array size value in the editor.
• Fixed several confusing errors related to Apply Changes to Prefab and ALT-dragging prefabs.
• Fixed a bug where overriding part of a prefab instance would result in other elements in the array being cleared incorrectly. Changing any value in an array now marks the entire array as overridden.
• The weight of animation states will now be set to zero when starting a cross fade of another animation state in the same layer with a zero cross fade time.
• Fixed AudioSource.maxVolume not being settable from a script.
• Fixed bug in JavaScript when assigning to a field would fail in a struct that is a private variable from inside of a coroutine.
• Enabling Compress Textures now works correctly when the project folder contains more than 4GB of textures.
• Fixed issue in FBX importer when importing blender files through old Collada (.dae) file importer.
• Terrain inspector now draws correctly into a scrolling inspector.
• Flatten Terrain can now be undone.
• The Mesh Importer no longer remaps the skinned mesh to the root bone if there is more than one skinned mesh in the file.
• Reduced memory consumption when importing a lot of assets.
• Fixed issue where loading Mac OS X standalone would fail if the company name in the player settings contained backslashes.
• Windows standalone games work from network shares now.
• Fixed a bug where selecting Compare in the Server menu would ignore the current selection and compare all assets if the server view was not visible.
• Fixed rare crash when cleaning up coroutines.
• Fixed crash when there are multiple terrains using one terrain data object.
• Fixed crash when exiting fullscreen directly on Mac OS X through OpenURL call.
• Fixed Fatal Error when importing more than 30.000 assets at once in a project folder.

Unity 1.6

We've been hard at work acting on the needs of our many users. This is a list of the main changes that have gone into Unity since Unity 1.5.1.

Graphics, ease of use, minor features

• Any texture size is now supported (lifting the requirement to have texture dimensions of 2, 4, 8, 16, 32, 64, 128, 256, etc.) This both means than any image can be used as a texture, and that it's much easier to do pixel-perfect game GUIs. The WWW class now fetches images without padding them.
• Cinema 4D 10 is now fully supported.
• Quality Settings are fully switchable at run time. Scripts can access a QualitySettings class to change current quality level.
• The separate Web Player quality level was removed; and default standalone and web-player quality levels are set up in Quality Settings as well.
• A different icon now seperates imported and created prefabs. It's useful to see what's what since they work differently (imported prefabs can't be modified).
• The Unity Web Player can now hide the cursor while it is over the area of the plugin. Use Screen.showCursor = false; to enable this behaviour.
• The player window on OS X starts centered on the screen instead of on the top left corner.
• Application.loadedLevel will now refer to the correct "Build Game" dialog index number when testing scenes in the editor.
• The Mesh import settings dialog is now resizable, to make splitting animations into many parts easier.
• The name of a prefab is now always overridden and will not change when the prefab name changes.
• The name of the physics material will now stay the same when instantiated through Collider.material.
• Scripts can now be dragged into the empty area of the inspector to add the script to the selected game object.
• Tabbing through the inspector is more consistent now.
• Inspector properties are no longer edited by a mouse click that activates Unity. Thus one no longer can accidentally change values like this.
• Moved Quality Settings menu item into Project Settings submenu because they are project-wide settings.

New scripting functionality:

• Added Resources.Load() and Resources.LoadAll() functions. You can now place assets in a folder named "Resources" inside the project folder. Assets inside this folder (and only these) can be loaded at runtime, by referencing them by name or path.
• Added Input.GetButtonUp(), Input.GetKeyUp(), and Input.GetMouseButtonUp() functions.
• Added Application.CancelQuit() to stop or delay a standalone player from quitting. This function is useful to call from inside an OnApplicationQuit() handler. It is perfect for showing a splash screen just before the user leaves the application.
• Added transform.forward, transform.right, transform.up convenience properties.
• Added JavaScript parseInt and parseFloat functions.
• Added GetScreenRect() for GUI elements (GUITexture and GUIText).
• Added Graphics.deviceName, Graphics.deviceVendor and Graphics.deviceVersion.
• Added Screen.currentResolution property.
• Added a WWW.progress property and WWW.LoadUnityWeb() function to the WWW class.
• Added RaycastHit.triangleIndex and RaycastHit.textureCoord.
• The constructor of GameObject now takes an optional list of components that should be added to the game object automatically.
• Added Texture2D.SetPixels() to set all pixels in a texture in one go, vastly improving performance.
• Added Texture.wrapMode property.
• Added Mathf.Log() and Mathf.Exp() functions.
• Texture2D.SetPixel() now automatically clamps / repeats out of bounds pixels automatically. This makes using RaycastHit.textureCoord a lot easier.
• The transform and rigidbody accessors in RaycastHit now return null if nothing was hit (instead of throwing an exception).
• Collision.collider property now is always set to a collider even if a Rigidbody was hit. This is more intuitive than the old approach of returning null if a Rigidbody took place in the collision.
• SendMessage() functions can automatically convert between float and int.
• Vector3.back, Vector3.left and Vector3.down properties have been deprecated. Use -Vector3.forward, -Vector3.right and -Vector3.up instead.

Bug fixes

• GUI Textures now always display pixel correct.
• Pixel point lights now attenuate towards completely black at their maximum range (instead of a dark gray).
• Fixed jitter when using Rigidbody interpolation.
• Fixed bug in animation splitting when using loop-frames.
• OnCollisionExit() will now be called even if OnCollisionEnter is not defined.
• new WWW (url) can now be accessed from C#.
• Double clicking on a texture in the material inspector will now open the texture in Photoshop (or whichever application you have selected as the texture editor application).
• When assigning references to objects in the inspector using the popup-menu, classes that inherit from MonoBehaviour will now be checked for their exact type and only listed if the type matches exactly.
• When rotating a parent transform, with transform children that have a kinematic rigidbody, the position change from the rotation will now be applied correctly. Previously the world space position of the transform would not change.
• The Unity Web Player's context menu now always works on Firefox running on OS X.
• Fixed some .NET classes failing to load in standalone Windows players (ConfigurationException: Cannot find …\Data\etc\mono\1.0\machine.config).
• Windows standalone player will no longer switch to rotated full screen resolution.
• Invalid characters now get removed in Product Name and Company Name in Edit->Project Settings->Player. Certain characters would lead to the built player application not being able to launch.
• Alpha of main color in all shaders is now 100% by default.
• The InputManager's "Should quit on CMD-Q" checkbox has been removed. Application.CancelQuit() can do the job better now.
• Calling ToString() on an enum is no longer disabled in the Unity Web Player.
• Fixed Unity Web Player scrolling flicker in Safari.
• Fixed an issue where single quotes in script filenames named led failed compilations.
• Fixed a bug where resizing arrays of custom structures sometimes failed.
• Fixed crashbug when the mesh particle emitter has lost the reference to the mesh and emit mode is set to Systematic.
• Fixed cubemap inspector not displaying face images correctly.
• Fixed misleading label for 1/4 and 1/8 texture resolutions in Quality Settings (used to show 1/8 and 1/16).
• Fixed issue in the automatic triangulation of quads when importing models.
• Fixed bug in property inspector scrolling to the beginning when right-click dragging values fast.
• Fixed a crashbug that rarely and randomly happened when switching between inspectors.
• Fixed Flare fade checkbox to actually work.
• Fixed crash occurring when setting the tag of a behaviour inside of the constructor.
• Worked around Maya FBX exporter bug, where Maya batchmode would crash when using IK Constraints on some characters.
• Prefab changes are now propagated when using Application.LoadLevel() from inside of the editor.
• When going to fullscreen in the web player, the resolution and refresh rate is now clamped to the desktop resolution. This helps making sure that the Unity Web Player never switches to a resolution the monitor does not support.

Driver workarounds

• Fullscreen mode for S3 Savage cards with old drivers on Windows used to be disabled. Now entering directly into fullscreen from standalone is supported.
• Worked around a crash on older FireGL drivers on Windows (this is the same issue as with old Radeon cards: vertex programs get parsed wrongly)
• Worked around crashes and wrong rendering on Radeon 7x00 cards under Windows (disabled VBOs).

Unity 1.6.1

Upgrading Projects

When uprading Unity you may want to also upgrade your projects to gain access to all the new features. Open your old project and then import the Standard Assets and Pro Standard Assets packages (the second only if you are using Unity Pro).

All-Round Improvements

Yet again we've collected and categorized hundreds of your suggestions and bug reports, fixing each and every one we could.

Improvements

• The Collada .dae importer has been greatly improved. Collada files can now have two separate UV sets, and vertex colors also import correctly now.
• A #pragma strict keyword can now be used to disable dynamic ("duck") typing in JavaScript. This is useful when you want to not accidentally make use dynamically typed function calls, thus ensuring that your code runs at maximum speed.
• Support for Internet Explorer plugin activation. Web content on IE ignores input until it's activated, but the plugin can now be activated by using external .js files to load the plugin. See the web player manual section for more information.
• In the web player, the WWW class now downloads through the browser's API, allowing downloads to be cached by the browser. This improves streaming for the web plugin a lot. This means that WWW downloads are no longer able to stall until the download is complete (the API of common browsers does not allow this). We deprecated all functions which will stall a download, and are now giving an error when a download is being used before complete. Instead of stalling the download simply use yield WWW;. Web players published with Unity 1.6.0 or earlier will of course continue to work.
• The automatically generated web player html has been simplified. The documentation on the Unity Web Player HTML and browser communication has been rewritten.
• Script examples in the documentation are now syntax-highlighted.
• Added scripting function Material.GetTag(), to detect which subshader is being used in a shader.
• GUI elements and colliders are now ignored for OnMouseDown(), OnMouseEnter(), etc., functions when they are in the Ignore Raycast layer.
• Unity's Game View support for 16:9 aspect ratio was added.
• Reflective and Refractive Water shaders now render faster on old cards (specifically Radeon 7x00, Intel 8xx, and GeForce 2/3/4). For better performance the unnecessary camera is now disabled when the fallback is active (to get this, you need to re-import Standard and Pro Standard Assets packages into your projects).
• Width and height is now passed into postprocess build scripts. The current directory in the postprocess build player script is now always set to the project folder.
• Doppler is turned off by default now. To enable it, go to the Edit -> Project Settings -> Audio and set Doppler Factor to a non-zero value in order to activate it.

Known issues

• On some computers, the Unity editor does not launch. Unity will bounce one time in the dock, then quit. This is a bug in OS X 10.4.8 that triggers on some Intel-based Macs. The bug has been fixed in upcoming Mac OS X 10.4.9 update. Until it's released the problem can be solved by reinstalling the system or booting from another hard drive. The Player and Web Player are not affected by this.
• The Unity Web Player running in Firefox on Windows computers sometimes runs slower than it does in Internet Explorer. This is a bug in the Firefox "TalkBack" feature (FireFox's automatic bug reporting system). It specifically causes the context switches in OpenGL to take a needlessly long amount of time. You can make the Unity Web Player run fast again by simply turning off TalkBack in Firefox (Tools -> Add-ons menu). The performance issue is not very noticable with simple players, but if you use Render Textures or Image effects (for example reflective surfaces, blur, glow) the performance decrease can be quite drastic. The same issue also applies to other browser plugins (as for example Adobe Shockwave).

Bug fixes

• GetComponents() now gives an error instead of crashing when called from an object's constructor.
• Setting a reference to a component from a builtin components works again.
• Various issues with audio playback with pitch & doppler have been fixed.
• "Maximize on Play" on Unity's Game View now sets Screen.width & Screen.height before play begins.
• Made Matrix4x4.SetOrtho() to work correctly.
• Fixed a problem where skinned meshes having just one bone would sometimes incorrectly not be recognized as being skinned.
• Application.dataPath now works correctly in the Windows web player.
• Creating new assets from the Assets menu would fail when any project settings were selected.
• If a standalone Windows player crashes, the crash-report is saved into a separate folder next to game executable.
• Fixed an issue where particles would sometimes have huge initial velocities when a particle system was created in the editor.
• Fixed an issue where particles with very high energy in some cases aren't emitted.
• Fixed a graphics issue where flickering could occur when using the ColorMaterial keyword in a shader.
• Fixed rendering corruption when Halos are used on some Windows graphics card drivers.
• Fixed issue where script compilation would stall when encountering more than 32 errors or warnings.
• Fixed a bug where compilation would sometimes halt when importing a .unitypackage while having many compile errors.
• Fixed two regressions in the JavaScript compiler related to scoping of identical variable names.
• Fixed an issue in .obj file importing where UV coordinates would sometimes get lost.
• When making a game object DontDestroyOnLoad() without making the parent game object DontDestroyOnLoad. Instead of crashing, Unity will now warn about this since it's most likely not what is wanted.
• PlayerPrefs are now cleared when loading a new web player instance, but they are retained when using WWW.LoadUnityWeb();. This can be used to persist data between level loads when streaming .unityweb files.
• Fixed memory leak when stopping audio sources which use Ogg Vorbis.
• Fixed bug where Unity would behave inconsistently when a prefab was deleted in the Finder, and a new one created shortly afterwards.
• Fixed mouse cursor jittering when using right mouse drag in the editor.
• Fixed a problem where textures loaded via the WWW interface sometimes would not show.
• Fixed Windows Web Player crash on Firefox 1.0.x.
• Fixed Web Player installation and update failing on Windows in some rare cases.
• Fixed crash when importing non-power of two textures with some (large) texture sizes.
• Fixed bug with Export Package causing rare crashes when exporting entire scenes.
• Fixed a crash when disabling a camera from inside OnPreRender() or OnPostRender().
• Fixed a crash when ParticleEmitter.Emit() is called with a negative value.
• Fixed a crash when assigning null texture on a GUI Texture from script.
• Fixed an occasional crash when accessing GUIText.pixelOffset, material.mainTextureOffset and material.mainTextureScale on Windows and Intel-based Macs.
• Fixed a crash when using multiple image effects on a camera rendering into a Render Texture.
• Fixed a crash when max emission of a particle emitter in one shot mode was set to infinity.
• Removed spurious error "!CompareApproximately" that would sometimes show up when using interpolation on a rigidbody.

Driver workarounds

• Render textures now work on Intel graphics cards on Windows.
• Vertex programs are now enabled on GeForce4 4200 Go cards.
• Worked around guiText.material.color not always updating on Mac OS X, caused by a bug in Apple's Radeon X1x00 drivers.

Unity 1.6.2

Unity 1.6.2 was released in response to Apple's buggy Mac OS X 10.4.9 update, which in some cases made Unity stop working on Intel Macs after the update had been applied. But we still went through your bug reports and fixed most of them.

All-Round Improvements

Yet again we've collected and categorized hundreds of your suggestions and bug reports, fixing each and every one we could.

Bug fixes

• Fixed an issue where Unity wouldn't launch on Intel-based Mac OS X 10.4.9 computers due to bad prebindings caused by the 10.4.9 updater.
• Fixed a bug where more than one image effect on a camera targeting into another render texture would crash.
• Fixed random crashbug in Skinned Mesh Filter when animate normals is disabled.
• Fixed issue with Dashboard Widgets crashing when they are being reloaded using CMD-R.
• Fixed Internet Explorer activation in web player when using external JavaScript.
• Fixed loading issue on Windows when the executable is contained in a folder using Unicode characters.
• Fixed web player hang or crash on Windows when navigating very fast between pages.
• Fixed sound volume sometimes not updating correctly when changing listener volume.
• Fixed front and back audio channels being reversed on a 5+ speaker setup.
• Fixed bug where scale was sometimes not applied correctly when using animation clips.
• Layer Mask on Character Controller is now setup correctly.

Driver workarounds

• Fixed crash on Intel 9xx cards on Windows when render textures and image effects are used.
• Fixed rare crash on graphics cards that don't support DXT texture compression.
• Fixed incorrect uploading of DXT compressed cubemaps on some drivers.
• Fixed render texture crash on some Vista OpenGL drivers.
• Disabled render textures on old ATI FireGL drivers (they would often crash).
• Disabled multi-threaded web player rendering on old NVIDIA drivers and some SiS cards (they would crash sometimes).

Unity 1.5

A newer version of Unity has been released since Unity 1.5. Check out the current release notes to find out what's really new.

Major New Features

Feature #1: Windows web-browser plug-in

With the new Windows web browser plug-in, Unity web games are ready for prime-time. Just create your content normally, then use the File -> Build Settings… menu to take your web game live.

Your games will get the attention they deserve.

Feature #2: Character Animation

Unity 1.5 has a brand new animation system. It now supports animation blending, mixing, additive animations, walk cycle time-synchronization, animation layers, control over all aspects of the animation playback (time, speed, blend-weights), and mesh skinning with 1, 2 or 4 bones per vertex (can be controlled with quality settings) – in addition to our classic ragdolls.

But don't let the buzzwords scare you – it's still easy to set up and use.

Feature #3: Universal Binary

You've got a brand new MacBook Pro: now what pro software are you gonna run on it? Unity, of course. Unity 1.5 is now a fully universal application – so you can make your games even faster than before.

We've been testing Universal Unity for the past months, so we know it'll fry you with its speed-induced heat.

Feature #4: High-speed Car Physics

Ever wanted to drive at insane speeds? Now you can get that off your chest by making your very own racing game. For Unity 1.5 we've added a dedicated wheel collider that accurately simulates the traction model of real cars.

It has never been so easy to create racing games, or for that matter cool mountable vehicles for your first person shooters. Wheel Collider docs

Feature #5: More Full-Screen Filters!

We added another batch of filters to really make your Unity games shine. Use the Noise Filter to get a grainy black-white look (complete with hair on the film stock). Make your sci-fi worlds live in vivid colors using the Glow Filter. Or give life to your horror game with the dynamic Contrast Stretch. This is a Unity Pro feature.

Feature #6: Mesh Script Interface

In Unity 1.5 you have full access to all vertex data / normals / tangents / colors / UVs and triangles.

Generate infinite terrains, deform objects, break or merge objects. The interface is simple, and ridiculously fast too: we measured 1,200,000 vertices processed per second. With JavaScript! Mesh documentation

Feature #7: Textures Script Interface

Generate or modify textures on the fly. Or use textures as source data for anything (generate terrains from heightmaps, analyze image colors, …). Texture2D documentation

Feature #8: Particle Script Interface

The last entry in Unity's new full control programme is a fully exposed particle interface. You can now manually spawn particles and give them arbitrary position, velocity, size, and color. You can loop through all existing particles and animate them from a script, adding or removing particles you want. ParticleEmitter documentation

Feature #9: Lightmap Support

Now lightmaps are fully supported. Bake the light in your 3D app of choice, then import painlessly into Unity for that contrastful look.

Feature #10: TrueType Typography

Just drag any TrueType font (.ttf) into the project. Create a GUI Text or Text Mesh and drag the imported font onto the font property.

Feature #11: Cinema 4D Importer

Cinema 4D files are now imported natively. If Cinema 4D is not already running Unity will launch it and automatically install a converter plug-in. The whole process is completely seamless, just drop your .c4d files into the project.

Feature #12: Documentation & Tutorials

We now have 5x as much documentation as before. Everything has been read, reread, corrected and polished. All components now have annotated screenshots. Thanks to Sam Kalman for helping us out on this project.

Unity 1.5 also includes five tutorials covering a wide range of topics.

After all, what good is the world's best tool if you can't figure out how to use it? Documentation & Tutorials

Other New Features

In addition to the above Unity 1.5 includes more than 256 new small features, improvements. Here are most of these.

Graphics

• Fullscreen AntiAliasing and Sync to vertical retrace (Set it up in Edit -> Quality Settings)
• Improved texture compression quality and speed. We also now support DXTC5 texture compression which is better for textures with compressed alpha.
• Water cleanup/additions:
  • Water prefab now reflects the skybox
  • Wave speed is now independent of wave scale
  • Made property names clearer
  • Added reflective & refractive water in Unity Pro
  • Optimized the shaders
• Pro Standard Assets:
  • Added reflective & refractive water
  • Optimized all water shaders, made property names clearer
  • Added Glow, Noise and Contrast Stretch image effects
  • Glow uses extra brightness from alpha channel, you may want to set main color of your materials to use zero alpha
  • Blur image effect more efficient at doing large blurs
  • Edge Detect effect now uses a different and faster filter
  • Image effects now no longer print "no subshaders..." warning on old video cards
• Builtin shaders cleanup:
  • Added lightmapped shaders
  • Properly handle texture placement offset
  • Work nice with glow (put extra brightness into alpha, i.e. specular highlights)
  • Diffuse shader is now truly per-pixel, so you can have bright lights near big polygons
  • There is a Diffuse (fast) shader which does the same as the old diffuse
  • DiffuseDetail now does a proper detail texture (i.e. gray texture has no effect)
  • Most of the shaders are faster
  • Skybox shaders use background render-queue
• Added light culling mask. This allows you to selectively apply lights to only some objects
• GUILayer now renders after all image effects
• Shaderlab now supports Fallback off statement, which won't complain if no subshaders can run
• ShaderLab now uses the Cg 1.4.1 compiler

Scripting

• When calling a coroutine from JavaScript it will automatically be started. Thus it's no longer necessary to use StartCoroutine. In C# you still have to do this
• Added an Array class to JavaScript which behaves exactly like ECMA 1.5 standard JavaScript.
• Improved dynamic typing in JavaScript
• Renamed FileTexture to Texture2D
• Renderers can now be made invisible: Use renderer.enabled = false;
• Added Animation WrapMode.ClampForever, this is very useful with additive animation blending
• Added GameObject.CreatePrimitive() function for creating primitives from code
• A Material's texture placement (offset & scale) can be set from scripts
• Added a SendMessageUpwards() function
• Fog and ambient lighting settings are now exposed to the script interface. Use RenderSettings.fogColor = Color.white;
• GetComponent() can now also be used with a string. This is useful for accessing scripts written in other languages
• Added AddExplosionForce() and ClosestPointToBounds() function to rigidbody
• Scripting access to make rigidbodies sleep and solver iteration count:
  • Sleep minimum velocity can be overridden per rigidbody.
  • Rigidbody.Sleep() can force a rigidbody to start sleeping

Physics

• Rigidbody interpolation. This is an extremely important feature if your main character or vehicle is a Rigidbody. This will remove any stuttering on the Rigidbody, which is most visible when you have a camera following it. For non-player Rigidbodies, there is no need to use interpolation as it doesn't make any visible difference and comes at a tiny performance cost
• Improved CharacterController stability. You can now use the CharacterController from inside the Update() function too. Movement also appears smooth now

Runtime

• Joystick improvements: Unity now contains an XML file for overriding reported joystick minimum and maximum values (Saitek joysticks report skewed min and max values). If you have a joystick that doesn't work correctly please try adjusting the XML file and send back the results so we can ship them to all Unity users
• Improved multi-monitor support. When going fullscreen, Unity will now choose the monitor that the screenselector was placed in
• Alt-Enter now toggles fullscreen mode in standalone Windows players
• Project Settings now have an option to always display the Unity watermark

Performance

• Quality Settings made much more flexible. They allows you to associate graphics quality settings to the ScreenSelectors quality setting
• Using skyboxes is much faster now (does depth clear in hw-friendly way)
• Editor performance optimizations in high object count scenes with a lot of gizmos
• Up 300% performance improvement when rendering skinned meshes. You can selected the number of weights used per bone (1, 2 or 4). It is also possible to select the accuracy used when transforming normals. If your mesh is not scaled, Fast will look just as good as Accurate but take up much less processing power
• 300% performance improvement for rendering of high poly count meshes on Windows
• By default imported skinned meshes are now set to only process if visible. This implies that the bounding box will not change after it has been built the first time. If you are not animating a character but for example a big crane and you see the object popping into view too late, disable only update if visible.

Editor

• Greatly improved editor grid rendering
• Added Layers menu to Scene View
• Renamed inspector expert mode to debug
• Renamed LightManager to Render Settings
• Renamed ProjectSettings to Player Settings
• Performance optimizations when entering playmode in the editor
• Improved null reference exception messages. When encountering exceptions, Unity will now display much more readable warnings about what has gone wrong:
  UnassignedReferenceException: The variable target of SuperMarioCamera has not been assigned. This happened in the game object "Main Camera".
  You probably need to select the "Main Camera" in the hierarchy and assign the target variable of the SuperMarioCamera script in the inspector.

Asset importing

• Support for Collada 1.4 files
• Support for importing .dxf and .obj files
• Added Collada based Blender importer. This fixes several bugs in the handling of rotations and pivot points (some Blender files would import rotations incorrectly). While this version doesn't add any new features, it will allow importing animations once the Collada exporter for Blender supports it. At the moment it supports importing UVs, normals, and vertices. This importer is more streamlined and requires Blender version 2.4. If you have a Blender file that was already imported with an earlier version of Unity, in order to stay consistent with the old imported file the new Blender importer will not be used. To use the new importer simply duplicate the Blender file in the Finder.
• Unity packages (.unitypackage) can now be opened with a double click in the Finder
• The default global scale when importing .fbx files directly is now 0.01 instead of 1.0. This fits how most modelers except Maya work.
• Worked around several issues in the Lightwave .fbx exporter when exporting meshes with assigned textures. You can now assign multiple textures to the same mesh in Lightwave and it will import correctly into Unity

Text and GUI

• Added GUI Text pixelOffset
• Added a Create 3D Text menu command. This will create a complete Text Mesh. Selecting a font asset before fist will assign that font to the created Text Mesh
• GameObject -> Create -> GuiTexture now creates a GUI Texture with the size of the texture that will maintain its pixel size regardless of resolution

Bug-fixes and polish

• Audio Listener added to FPS camera prefab in standard assets
• Unity now works around an issue with a new version of the (now broken) Quicktime LiveType.component
• When playing an animation and it is the last active animation, it will clamp to the last frame instead of just stopping before the frame
• Updated OS X version of the web player to support multiple plug-in instances and work better with FireFox
• Added background render-queue and fixed overlay render-queue to work correctly
• Remove ambient light scale property from light manager inspector
• Fixed water shader and reflection shader on Intel cards
• Fixed progress bar in the web player
• Fixed Dashboard Widget loading to be backwards compatible
• Fixed menu bar not being restored correctly after fullscreen
• Fixed game view sometimes drawing garbage pixels on screen
• Fixed layout issue in preferences dialog
• Default camera doesn't contain skybox component by default anymore to avoid confusion (use Edit -> Render Settings instead)
• Fixed crashbug when using imported meshes with zero vertices
• Fixed move tool handles becoming black on rare occasions
• Fixed Blender importer bug when using orthographic cameras in Blender
• Worked around NVIDIA graphics card issues with water on OS X
• Fixed fallback effects not using UsePass/GrabPass correctly. This resulted in ATI cards not falling back correctly with bumped specular shader
• Fixed Edit -> Select All to work correctly
• Fixed a error where Unity would not allow building a web player when using some JavaScript features
• Fixed minor bugs in the script interface of the Light component
• Fixed particle systems animating when not selected and in edit mode when moving around in scene view
• ShaderLab now supports different line endings (LF, CR, CRLF).
• Fixed 50mm flare in standard assets
• Fixed Line Renderer color interpolation issue
• Fixed rare crash or reboot when recompiling shaders often
• Fixed crashbug when setting Hinge Joint damper value to less than zero in the inspector
• Fixed bug where Unity didn't hide the menu bar correctly in fullscreen mode
• Fixed crash in texture upload on Windows when using Fastest display quality or using Texture.masterTextureLimit
• Fixed bug in particleEmitter.particles when assigning energy and color
• Fixed wrong values shown in material inspector after doing a Reset
• Fixed crashbug in mesh particle emitter when the mesh contains no normals
• Worked around OpenGL driver bug on Geforce FX 5200 cards using PowerOfTwo Render Textures
• On Windows, three argument texture combiners (a*b+c, a*b+-c) now work on nVidia cards
• Worked around an Apple OpenAL crashbug when playing streaming Ogg Vorbis sounds. The workaround simply preloads the whole Ogg Vorbis instead of streaming it. We are pushing Apple to fix this issue, so that we can enable streaming Ogg Vorbis sounds again
• Tool handle doesn't wiggle anymore when a particle system is selected
• Fixed raycast collider triggers to report trigger events correctly on Windows
• Fixed exiting fullscreen mode in OS X standalone player to fade out correctly before the resolution switch
• Fixed crashbug that sometimes occurred when starting Unity and hitting play
• Fixed a crashbug when storing an AnimationState in a member variable
• Fixed wrong colors in 2x2 MIP level when using RGB 24 bit textures
• Fixed a rare crash when setting material properties from scripts
• Screen.showCursor = false; now actually works on Windows
• Folders with extensions in the path name are now displayed correctly in the editor
• Fixed rare (and random) crashbug when recompiling scripts
• Fixed issue where the lowest MIP-map levels of compressed textures would sometimes result in random pixels
• Holding down shift while dragging the scene view camera actually moves 3 times faster now
• Fixed bug when loading the first level multiple times, where triggers would sometimes fail working
• Fixed several joystick input bugs:
  • Screen selector input configuration for joysticks has a less sensitive deadzone when configuring now
  • Mouse buttons can now be configured
  • Configured key names shown in the screen selector are nicer formatted now
  • The idle center of the joystick is calculated correctly now
• Fixed wrong lighting bug when multiple pixel lights are placed at the same position
• Fixed possible lockup on Windows when switching from fullscreen to windowed mode on some drivers
• Fixed lighting issue when using bump specular shader on skinned characters (tangents were not transformed correctly)
• When unpausing the player all input will now be reset:
  • Activating the player window with a click will not let the mouse event go through)
  • Fixed an editor issue, where a key became sticky when pressing command and an arrow key at the same time
  • Keys will never get stuck
• Fixed an issue where changing scripts while in playmode and using animations sometimes would disconnect the animation state
• Fixed a JavaScript issue in web player
• Fixed scene view losing camera position setting when going into playmode while a view is maximized
• When going out of game mode and a scene view was switched into a gameview it will now be restored
• Fixed "invalid IL" crashbug when implicitly casting floats to bool in JavaScript
• Fixed LightManager flare strength not updating live
• Fixed annoyance where a wireframe would sometimes go out of sync with real mesh when changing scale
• Fixed reflective shaders on Intel GMA cards (MacBook, Intel MiniMac)
• Fixed water to display better on Intel GMA cards
• Fixed fallback effects not using UsePass/GrabPass correctly
• Fixed Render Texture clearing on GeForce cards
• Fixed possible lockup on Windows when switching from fullscreen to windowed mode on some drivers
• On Windows Unity no longer thinks GeForce 6/7 does not support 3D textures :)
• Fixed wrong lighting bug when multiple pixel lights are placed at the same position

Unity 1.5.1

When making middleware for such a wide audience as we do, one of the challenges is that many of the end users of our customer's games have outdated hardware and graphics drivers. The solution? We've spent massive resources testing our runtime on these platforms. Thus, we're proud to announce Unity 1.5.1, with rock-solid support for a terrifying range of old hardware/software combinations.

Major New Features

Feature #1: Support for old hardware and drivers

When making middleware for such a wide audience as we do, one of the challenges is that many of the end users of our customer's games have outdated hardware and graphics drivers. Some of these drivers are awfully broken, and functionality that is documented to work, doesn't. The solution? We've spent massive resources testing our runtime on these platforms and working around driver bugs. Thus, we're proud to announce Unity 1.5.1, with rock-solid supports for a terrifying range of old hardware/software combinations.

While not the sexiest of "features", the benefits are massive: reduced support costs, reduced quality assurance, and increased market reach. The result is that you have more time to make a great game. This is critical to anyone who wants to make games for a wide casual audience.

Feature #2: Unicode Support

Unity finally supports Unicode for game localization. Japanese? Chinese? Korean? Not only westerners play games.

Unicode TrueType fonts now import correctly and it is possible to enter Unicode characters into strings in the inspector. Scripts can even be saved in the UTF16 encoding which allows them to contain complete Unicode strings.

Feature #3: Car Wizard

Unity 1.5 brought high-speed physical modelling of vehicles, with suspension, tires and that whole racing-thing. With Unity 1.5.1 it's become really easy with a new "car wizard". Drag in a car model, run the wizard, set your parameters, drive.

But don't let the buzzwords scare you – it's still easy to set up and use. A web player The Race demo project

New Example Project #1: 3D Platform Game

Want to make a 3D platformer in the style of "Super Mario 64", complete with jump-pads, feel-good camera controls, and a cute (or scary) animated character? This example project has scripts to control such a game. Loads of goodies include: scripts, 3D objects and rigged character complete with textures and animations.

As always, the assets from the example projects can be used free of charge commercially (and well as non-). The scripts are well written and can be extended and repurposed. 3D Platform Game project

New Example Project #2: Nature Rendering

To help you create gorgeous terrains with foliage such as animated grass and trees, we added this example project. It includes several really cool parts: A grass generator script to dynamically generate leaves of grass across a terrain mesh, foliage and terrain shaders, and two fully textured sample trees.

As always, the assets from the example projects can be used free of charge commercially (and well as non-). The scripts are well written and can be extended and repurposed. A web player The Nature Rendering project

All-Round Improvements

We weren't relaxing these last months. We've been hard at work responding to your suggestions and improving Unity back to back. Unity supports native importing of files from the newly released packages, Maya 8 and Cinema 4D 9.0 + 9.1, and improves the native support for complex hierarchies in Blender.

Unity 1.5.1 has also been optimized. Complex scenes render 15% faster, and a new script has been added to combine objects, which can provide for massively increased rendering speeds.

Ogg Vorbis playback improved

• Improved playback of very short Ogg Vorbis clips on Intel Macs and Windows.
• Enabled Ogg Vorbis streaming on Intel Macs on OS X 10.4.7+, because Apple's OpenAL driver has been patched.
• Worked around an issue in the Ogg Vorbis importing when a buggy QuickTime component is present.

Usability

• The New Project wizard is now clearer.
• Asset / object pop-up selector now sorts items correctly, and does not show any invalid items.
• Unity now waits until all scripts have finished compilation before entering play-mode.
• Improved Texture inspector now displays texture's size, format and compression.
• Improved Render Texture inspector. Size, wrap and filtering can be set up now.
• Improved icons for Fonts, Scripts, Unity scenes, Cubemaps, Shaders and Physic Materials.
• Improved display of WheelCollider components in the scene view.
• Alpha-only textures now display alpha channel automatically in the project view and inspector.
• Adding elements to completely empty string arrays in the inspector is now possible.
• Show a warning when trying to save scene outside of the project folder.
• Show a warning when saving two scripts with the same name.
• Worked around an issue in .fbx files containing duplicate bones.
• Worked around an issue in 3ds max's .fbx converter where path names would come through incorrectly, leading to textures not being found.
• Much improved scripting and ShaderLab documentation.

Scripting

• It is no longer necessary to manually cast when assigning a JavaScript array to a builtin array.
• Added WWW.bytes property to read raw bytes over the network.
• Added Physics.RaycastAll() and Physics.TestCapsule() functions.
• Added CharacterController.center property.
• Added Shader.Find() function which finds existing shaders by name.
• Added Input.GetAxisRaw() function which returns an input axis with no smoothing applied.
• Added GuiText.anchor, GuiText.alignment and GuiText.tabSpacing properties to allow complete script control.
• Added Mathf.SmoothDamp() function for a tunable smooth damping. Useful for following cameras.
• Added Mathf.SmoothStep() function.
• Renamed CollisionFlags.CollideSides to CollisionFlags.Sides. Added CollisionFlags.None. (CollisionFlags.CollideSides still works but is deprecated).
• Rigidbody.useGravity will now wake up a Rigidbody when enabled.

Graphics

• Massive improvements of graphics card and driver compatibility on Windows. We worked around a lot of broken graphics card driver bugs, including some very old ones. We have tested against most graphics cards with different driver versions. In particular:
  • Fixed rendering artifacts on most Intel cards (845, 865, 945).
  • Worked around older ATI drivers parsing vertex programs incorrectly.
  • Disabled software vertex programs on DX7-level NVIDIA and Intel cards.
  • Worked around a crash with render textures with pre-30.82 NVIDIA drivers.
  • Worked around a crash with pre-4.1.10.3691 Intel drivers.
  • Worked around crashes on S3 Savage/ProSavage/Twister cards.
  • Worked around a crash on VIA/S3 UniChrome cards falsely claiming they're OpenGL 1.2.
  • Worked around some SiS 630/651/730 drivers falsely claiming they're OpenGL 2.0.
  • Various graphics cards have trouble when performing rendering from a separate thread (most ATI and Intel drivers). Disabled multithreaded rendering on those.
  • On some ATI drivers, the Unity Web Player could hang when getting out of full-screen.
  • Unity Web Player on Windows now grays out full-screen menu item if it is not safe to switch to full-screen mode due to buggy graphics card drivers.
• Glow effect looks a lot nicer. Less white fringes around, finer control of glow color based on the object's color.
• The color of a text material can now be modified and is stored when closing the project.
• Graphics performance optimization with up to 15% faster rendering when many objects are visible.
• Decal shader now behaves similar to VertexLit, but with a second (decal) texture.
• Improved sorting for transparent objects. Transparent objects are now sorted by now sorted by bounding volume center instead of Transform.position.
• Particle shaders look much better on really old (single texture) graphics cards.
• Fixed glossy/specular vertex lighting suddenly changing sometimes (on full-screen switches and level loads).
• Intel integrated graphics cards now support vertex and pixel shaders on the Mac (MacBook and MacMini).
• When using animated particle textures in the ParticleRenderer, the UVs pointed to the wrong tile on the first frame.
• Linear eye-space UV generation (TexGen EyeLinear) in shaders now works correctly.
• Projectors are now culled correctly by the camera's culling mask.
• Fixed issue where the Projector flips textures vertically when using an orthographic projection.
• MotionBlur filter is no longer too dark on some Windows machines. It also runs on more graphics cards now.
• Spotlight cookies are not mirrored anymore.
• Flare layouts 2x2, 3x3 and 4x4 now work correctly.
• Fixed errors with Reflective shaders that would occur in some situations.

Unity Web Player

• Firefox on Intel Mac is now supported too.
• The loading bar is now drawn correctly for small games.
• Loads much faster and doesn't leak resources on OS X.
• It is possible to detect where the game was loaded from (both the srcValue and the absolute url) as Application.srcValue and Appliction.absoluteUrl.
• For computers that do not have any OpenGL drivers, a warning is issued before continuing with software rendering.
• Unity Web Player on Windows runs much faster in full-screen, and full-screen mode is entered faster.
• Unity Web Player mouse position in Firefox now works correctly.

Deployment

• Screen selector dialog can now be hidden by default. The new options in the player settings are:
  • Enabled by default.
  • Disabled completely.
  • Disabled by default, but shown when holding down ALT during launch.
• Reduced mouse sensitivity on Windows to be more like on the Mac.
• Unity games can now be run headless (without requiring a monitor), using a -batchmode command line argument (requires Unity Pro).
• Fixed an issue with OnMouseDown when using multiple overlaid cameras and culling masks.
• Fixed issues with keystrokes being lost and keys being stuck.

Other fixes

• Fixed issue in package importing on network-booted setups.
• Unitron no longer starts two recompiles (once when saving the file and once when activating Unity).
• Dashboard Widgets now render non-fullscreen cameras at the right position.
• Fixed an occasional crash when exiting a standalone game from the screen selector on Windows.
• ForceMode.Acceleration now works correctly. Previously the parameter would be on the scale of an impulse instead.
• Fixed an issue in Camera.WorldToViewportPoint() and Camera.ScreenToViewportPoint() functions when using non-fullscreen cameras.
• Random.RandomRange(min, max) integer function now returns min when min equals max.
• When creating Materials from code they are now shown in the inspector.
• SpringJoint.damper property now applies correctly when set from a script.
• Collider.bounds now returns the real bounding volume.
• ControllerColliderHit.normal now returns the correct surface normal (instead of sometimes returning its inverse).
• Fixed a bug where assigning a particles array would not allow resizing the rendered particles.
• Fixed a bug where Material.GetColor(name) right after creating the material from a script always returned black.
• Fixed an issue where split-screen cameras had inconsistent Flare rendering for the top-most camera.
• Fixed a crash which occurred when using GetComponent() with a null argument.
• Fixed a crash which occurred when providing negative coordinates to GetPixel() when texture wrap mode was set to repeat.
• Fixed a crash which occurred in a overridden OnEnable() function when recompiling scripts in play-mode.
• Fixed a crash which occurred in GuiElement.HitTest() if no current camera is available. It now uses an imaginary full-screen camera when no camera is found.
• Fixed a crash which occurred when setting properties of a Rigidibody created from a script, which is attached to an inactive GameObject.
• Fixed a crash that occurred on some computers when exiting Unity.
• Fixed a crash that occurred when using "1 texture" flare layout.
• Fixed several bugs that could crash Unity when importing some fonts.
• Fixed freeze which could occur when Unity is brought to the foreground.
• Fixed crash when setting the spring parameter of a Spring Joint.
• Fixed rare crash when using AudioSource.PlayOneShot() with Ogg Vorbis audio clips.
• Fixed crash bug on PPC based Macs with some Ogg Vorbis files.
• Fixed OpenAL loading on some Creative sound cards on Windows.
• Removed a warning saying that the editor scripts could not be loaded.
• Fixed an issue where drag&drop sometimes needlessly scrolled the hierarchy view horizontally.

Unity 1.2

Smaller features in Unity 1.2

As all our updates, Unity 1.2 contains a lot of features, optimizations and fixes. The more notable are:

• Animations are now clipped by the timeline, which makes it easier to create looping animations.
• Animations can now be set to either loop, ping pong or clamp.
• Gizmos are now drawn for the entire hierarchy below the selection.
• Meshes can now import vertex colors.
• Shaders can now define default textures.
• Added Object.DestroyImmediate() function, which should be used when writing editor code.
• Arrays are now shown in the inspector.
• Classes not derived from MonoBehaviour or Scriptable object can now be referenced and shown in the inspector (you need to use the [System.Serializable] attribute on the class you want to serialize).
• Improved class support in JavaScript.
• Added attribute support for JavaScript using @attribute.
• Application can be set to run in the background in Edit->Project Settings->Player or via scripting with Application.runInBackground.
• Graphics performance optimizations.

Bugfixes in Unity 1.2

• Render Textures now work correctly on Windows.
• Fixed a crashbug occuring when building a player.
• Fixed a bug where the player wouldn't run exactly like the editor, because the default Physics Material wasn't setup correctly.
• Fixed shader fallback of the Alpha/Diffuse shader on old graphics cards.
• Added several Physics Materials to the standard assets.
• PlayerPrefs class now works on Windows.
• Fixed 2 crashbugs in the Windows standalone player.
• The Windows standalone player can now be placed in folders containing non-ascii characters.
• Fixed crashbug occuring when assigning textures to a mesh.
• Dragging the camera in orthographic view works correctly now.
• Fixed a bug where textures would appear as missing.
• Fixed a bug where C# compile errors wouldn't open the script correctly.
• The Player can now run on case sensitive file systems.
• It is now possible to resize the Open Project wizard.
• Fixed several JavaScript parsing issues related to arrays, enums, the ?: operator, using new with structs when no constructor exists.
• Fixed crashbug occuring when modifying a material property from scripts.
• Fixed documentation for Random.Range() (off by one ;)
• MouseEvents (eg. OnMouseDown) now work with stacked cameras.
• Aspect ratio dropdown in the game view handles non-fullsize cameras better.
• Ogg Vorbis playback now works on Windows.
• Kinematic rigidbodies now send trigger messages.
• Fixed a bug in the Instantiate function occuring when using direct references to script instances.
• Fixed a mono related bug that prevented unity or unity players from starting up on some machines.
• GameObject.SampleAnimation now samples animation clips on hierarchies.
• Fixed Projector to work correctly with scaled meshes.
• Projector now has a gizmo.
• Reset for scripted components now works correctly.
• Fixed particle rendering crashbug.
• Fixed text rendering bug.
• Fixed Object.Destroy() to always be delayed in order to avoid invalid state in callbacks.
• Fixed rendering bug on some machines that made all objects disappear.
• Fixed cases when texture inspector would reject dragged textures.
• Cleaned up standard assets.

Upgrading Projects

After uprading Unity you may want to also upgrade your projects (to gain access to all the new features).

Open your old project and then import the Standard Assets and Pro Standard Assets packages (the second only if you are using Unit Pro). This will replace all the Standard Assets files in your project, so if you modified any of them you must take a backup first to avoid losing your changes.

Physics Changes

We've upgraded to a new version of Ageia's physX since Unity 1.1.1, which can cause changes in physics simulations. Read this post for tips on how to change your game if this causes problems.

Boo Changes

If you use Boo as a scripting language, there is a thing you have to be aware of. A bug previous to Unity 1.2 made protected variables be shown in the inspector. We fixed this, so they are not anymore. By default Boo creates protected variables, so previously they showed up in the inspector. If you want them to continue being shown in the inspector, you now need to mark them as public in Boo.

It is strongly recommended to fix your scripts before opening Unity 1.2, in order to not lose data in your scenes or prefabs (the loss of data happens when loading the project).

Unity 1.2.1

Bugfixes

• Mouse input now works even if USB overdrive is enabled or a Wacom tablet is being used.
• The bumped specular glass refraction shader now falls back correctly where pixel shaders are not supported.
• Fixed a bug in plugin loading on Windows.
• Right mouse button is now button 1.
• Fixed a JavaScript compiler error when declaring structs inside of a coroutines.
• Fixed a crashbug when adding a rigidbody to a plane.
• Fixed a crashbug when using public multi dimensional arrays in scripts.
• Fixed a crashbug when using a huge amount of coroutines at the same time.
• Fixed a memory corruption bug when importing textures with border mip map enabled. This sometimes made Unity crash or give errors when creating a new project.

Unity 1.2.2

Unity 1.2.2 adds a lot of gunpowder to the game-developer's arsenal, while still delivering solidly on the basic premise: making game development easy and efficient.

Unity 1.2.2

Universal Binary Games

Unity 1.2.2 produces games that work on Apple's sweet new Intel Macs (as well as Apple's sweet old PowerPC macs.)

This goes for all deployment targets: standalone, the Unity Web Plugin, and Dashboard Widgets.

Great Windows Support

Games delivered to the Windows platform now perform better, support hardware better, and offer a screen-resolution interface which is as good as that on the Mac. The built game looks really clean on Windows too: just one executable and one data-folder.

Harmony between the spheres.

(Screenshots from Phoenix Final, a game in development by Neil Carter.)

New Features

• Added screen-selector on Windows.
• Windows Standalone players now only contain an executable and a Data folder. DLLs have been moved into the Data folder.
• Added improved resolution handling on Windows.
• Improved joystick support on Windows.
• Performance improvements across the board.
• Screen.SetResolution can now set the refreshRate.

Bugfixes

• OnCollisionEnter contact normals now always face outwards of the surface hit. In some rare cases they used to be the opposite direction
• Fixed Skybox handling.
• Fixed flare rendering for directional lights when the camera has a faraway near-plan.
• Fixed a problem where Euler-angle rotation values entered in the inspector were garbled.
• Fixed bug in Selection.GetFiltered handling when requesting all selected game objects.
• Fixed a problem when stripping debug symbols of the standalone player, if the user didn't have the Apple Developer Tools installed. This is no longer necessary!
• Fixed crashbug related to rendering selection wireframe and wireframe getting out of sync.
• Fixed a JavaScript error when comparing dynamically typed objects against null.
• Fixed rare crashbug when multiple character controllers collided.
• Fixed rare null-reference exception when using coroutines in C#.
• Fixed a rare render texture crashbug on ATI 8500 / 9000 / 9200 graphics cards.
• Fixed rare crashbug when collapsing placement foldout in the material inspector.
• Fixed rare Windows crashbug related to lighting.
• Fixed spurious MeshRenderer "missing vertex colors" error.

Unity 1.1

Very Early Versions

A lot of water has flown under the bridge since those versions were released. Check out the current release notes to find out what's really new.

Unity 1.1

New Features:

• Added support for building Windows standalone player [Unity Pro feature]
• Added C/C++ plug-in support. As an example we added a MIDI plug-in with an accompanying easy-to-use Midi class (see the Manual's Plug-in documentation) [Unity Pro feature]
• Added support for an asynchronous WWW library which allows you to download textures from the web or communicate with web sites
• Levels can now be loaded from inside the editor so big games can be tested and tuned in full

Shaders:

• Refractive glass shader added [Unity Pro feature]
• 8 new virtual displacement bump-mapping shaders (sometimes known as parallax bumped)
• A number of shader fallbacks were improved
• Material color alpha is now 1 by default

Scripting:

• Added gizmo drawing interface
• Improved level-loading interface
• Added GameObject.Find(string name) to get game objects by name
• Awake() is now called after all objects have been fully initialized
• Physics.OverlapSphere() now compares against the actual geometry instead of bounding box
• The current directory now points to the folder the player application is in for easier file access

Editor and Workflow:

• Added Build menu item, which simply uses the last Build Settings for faster turn-around
• Scene view clip planes automatically adapt to the scene size. Zooming the scene view now behaves better for very large and very small objects
• Added support for importing Maya 4.5 and 5.0 files
• Frame selected now accounts for children of the selection

Physics:

• Collision capsules can now set in which direction height is to be applied
• Added anisotropic friction and contact springs
• Sphere collider now changes radius with scale

Documentation:

• Added a Scripting A Game Tutorial which walks through the creation of a full game. Another masterpiece by David Janik-Jones.
• Updated the Script Reference and added an overview over Unity's scripting API
• Rewrote script reference for transform and some other classes
• The documentation is now shown in browser instead of Unity

Bug Fixes:

• Objects are now correctly lit when scaling them to be very small
• Collision meshes were smoothed too much
• Changing the hinges break force to 0 crashed
• Added missing math functions
• The transform inspector now displays euler angles correctly and doesn't suddenly change rotations
• Fixed a skinning issue with characters imported from Lightwave
• Fixed crashes when importing broken 3DS files
• Fixed a crash-bug when removing a script
• Mesh particle emitters now take scale of the mesh into account
• Fixed a crash occurring when importing textures with the gamma correction import setting
• Fixed a crash occurring when setting the radius of a capsule to 0
• Fixed a crash occurring when using Import New Asset...
• Key configuration dialog now only writes preferences when the settings change
• Fixed the ortho graphic view drawing wrong
• Fixed crash bug when setting making particle emitter max energy negative
• Fixed skips when using center scale handle
• Fixed Particle Cloud errors and not serializing color correctly
• Games now including all scripts and physics materials
• Welcome screen doesn't disappear after opening a new web page anymore
• Fixed <= bug in JavaScript
• Material inspector now always updates textures correctly.
• Water now always turns the right way (you need to reimport the Pro Standard Assets package)
• ... and more

Unity 1.1.1

New Features:

• Added Capture Screenshot feature. The example in /Users/Shared/Unity/Script Tutorial/CaptureScreenshot.js shows how to make it capture a movie by writing a sequence of screenshots
• Support for Maya 7.0 .mb and .ma importing
• Performance improvements when importing .ma and .mb files
• Added Bake Simulation option to the Maya importer. This automatically bakes IK and expressions to animation curves
• Added support for directly importing Cheetah3D .jas files (requires version 2.4 of Cheetah 3D)
• Improved performance when using a lot of SendMessage. For example OverWhelmedArena now runs 50% faster
• Improved ray-casting performance
• Dashboard Widgets now have a full-screen button. They run a lot faster in full-screen mode
• Materials now import diffuse color and are better at locating the assigned texture

Shaders:

• Specular highlights now look correctly on BumpSpec and Glossy kind of shaders
• Tangent space calculate is completely rewritten and now allows for mirrored normal maps. Note: meshes using BumpMaps must be reimported
• Radeon 8500-9200 shaders look a lot more like the shaders on higher end graphics cards.

Scripting:

• Added isKinematic flag to the Rigidbody class
• Added GameObject.Find() function to find a game object by their name
• Coroutines will now always wait for at least one frame when using yield; or yield 0;
• Materials can now be assigned to guiText.material and renderer.material from scripts
• Coroutines can now be used as event handlers, eg. OnTriggerEnter () { yield WaitForSeconds (5); }
• Coroutines now keep running during level loads when marked as DontDestroyOnLoad()

Editor and Workflow:

• Scene view camera improved

Bug Fixes:

• Animations now no longer jump when playing the first frame
• Skinned meshes now work correctly when using offset pivot points
• Rewrote the mesh triangulator. Importing large concave polygons from 3D modellers now works correctly
• Importing FBX files with UV's from Lightwave is now more forgiving. Some Lightwave made FBX files didn't show uv's before
• Importing meshes with degenerate triangles now works correctly
• Importing of UVs is more robust now. This solves an issue when import UVs exported from Lightwave could not be imported
• Texture importer now chooses the correct texture format when importing textures that are black or white but have alpha
• Fixed 2 Blender import crash bugs
• Triangle mesh collider is more robust when using a lot of flat parts
• Screen.width and Screen.height is now correct when called from inside the editor
• Dashboard Widgets now render correctly when the monitor resolution is set to 16 bits
• Generated prefabs now correctly enforce that they can not be changed in the user interface
• Dragging a game object onto a script-property now assigns the correct instance

Unity 1.0

Very Early Versions

A lot of water has flown under the bridge since those versions were released. Check out the current release notes to find out what's really new.

Unity 1.0.1

Major Features:

• With version 1.0.1 web players and dashboard widgets can be publicly distributed.
  The web player is now fully sand boxed. This means some functionality is disabled when running in the web player. For example you cannot create or destroy files on the users machine when running in a web player. We also added a web player download page for end users (www.otee.dk/getunityplayer.html) The sample html page shows how to link to this website in case the user doesn't have the plug-in installed. Dashboard widgets automatically install the web plug-in.
  
• Added nine HOWTO documents
• Greatly simplified Transform script interface
• Added alpha mapped shader family (Diffuse, Bumped, Glossy, BumpSpec & VertexLit variants)
• Warnings and errors are now colored and have an icon in the console. The status view now bounces like the dock to make it more visible when an error occurs
• Finder-like renaming, ESC to cancel an edit in Hierarchy

Project & Inspectors

• Animation clips can now be renamed by adding an @ in the file name. eg. monster@run.fbx will have all animations named run
• The screen can now be used as a render texture
• Web player can now enter full screen mode using the context menu
• Converted more sample code to java script
• You can now create networked games using System.Net.Sockets API. This is a low level networking API. We will add higher level API's later on

Bug fixes:

• Fixed a bug where an external text editor would open a script two times
• Fixed the crash reporting popping up when tabbing in the property editor
• Added "Remove Component" to context menu again
• Alternate key for input axis now works
• Fixed a bug when auto updating the web plug-in
• Fixed a crash bug when going into full screen mode with the web player
• Using 600k less memory for deployed web players
• Optimized installation to take up less space
• Improved collider documentation
• Made graphics script interface have a better match with what you see in the inspector
• Added particle animation/render script interface
• Lens flares now track the light enabled state correctly
• Lens flares work with directional lights
• Lens flare scripting interface maps 1:1 to the inspector
• Component names look better
• Inspector now immediately starts editing when clicking on a property
• Added Audio Source & Lens Flare gizmos so you can select them from the scene view
• A default material is now always assigned to the mesh renderer when importing a mesh from 3DS, FBX or Maya
• Components can now be removed from scripts by calling Destroy() on the component you want to destroy. Eg. Destroy(light)
• Fixed a bug where Input.inputString did not work in the player
• The title bar now shows the project you are working in
• The color well is now always opened when clicking on the color in the inspector
• Skinned characters now handle the case when scale is applied to the skinned mesh correctly
• Record animation now doesn't ask if it should break prefab connection if it doesn't have to
• Javascripts can now use yield; instead of yield 0;
• Javascripts can now use the post increment operator eg. i++
• Javascripts can now use the post increment operator eg. i++
• Javascripts can now create new classes inside the script

Crash bugs:

• Fixed a crashbug when importing FBX meshes, instead we are printing a warning that triangulation failed and skip importing uv's or vertex colors. Working mesh triangulation will be fixed in the next release
• Fixed a crashbug when dereferencing a null pointer from the scripting language
• Fixed a crashbug when playing sounds on non-stereo surround sound systems
• Fixed a crashbug when importing audio files
• Fixed a crashbug when using Add All key frames in the time line
• Fixed a crashbug when ragdolled characters are added to a prefabs
• Fixed a crashbug when in a Javascript yield 0; transform.position.x += 1; was used

Known issues:

• On Geforce 5200 mobile graphics cards text sometimes disappears. This will be fixed with the next release
• Triangulation of meshes sometimes fails. We give a warning in the console when it happens. A workaround is to manually triangulate your meshes in your 3D program. This will be fixed with the next release
• Dashboard widgets don't get focus back correctly when looking at the back side of the widget and then going back again

A new release which will fix the outstanding known issues is scheduled very soon.

Unity 1.0.2

Scripting Improvements:

• Added a Transform FindChild(string name) to the Transform class

Documentation:

• Improved the documentation for several classes
• Some documentation pages were strangely formatted

Shader Improvements:

• Made the pre-multiply alpha blended shader fade out properly

Bug fixes:

• Worked around a driver bug on GeForce 5200 graphics cards on Tiger when drawing text
• Fixed a issue in Dashboard Widgets where it loses focus when switching to the backside
• Fixed a backwards compatibility issue with particle shaders
• The web player failed to automatically upgrade to the latest version
• Remove component now correctly warns when removing a component which another component depends on
• About box showed the wrong license type

Unity 1.0.3

Scripting Improvements:

• It is no longer necessary to specify the type of parameters in event handlers inside javascript. Eg. you can now write: OnCollisionEnter(collision) instead of OnCollisionEnter(collision : Collision)

Bug fixes:

• Worked around a driver bug on GeForce 5200 graphics cards that resulted in flickering lights and made text disappear
• Collision events are now sent to scripts attached to colliders with no rigid body
• Opening a file in an external editor on Tiger now works properly when the editor application is not running
• Published Dashboard Widgets now get a proper bundle identifier, allowing more than one Unity Dashboard widget to be installed at the same time
• Adding scripts using the component menu now works properly
• The installer now asks you to restart the web browser after installation
• The web plug-in is now drawn correctly inside Firefox
• Reported mouse position is now correct in the web plug-in inside Firefox
• Reported mouse position is now correct in the web plug-in in full screen mode

Unity 1.0.4

Bug fixes:

• First-time installation of Unity Widgets is now more stable

iPhone 1.7

Note: a newer version of Unity has been released since Unity iPhone 1.7. Check out the current release notes to find out what's really new.

Highlights

• Enables iPad deployment for both Unity iPhone Basic and Unity iPhone Advanced.
• Adds iPad Simulator support so you can develop iPad apps even if you do not have the hardware yet.
• Added universal application support so you can make apps that work both on iPad and iPhone.

Additional Features and Improvements

• Apple iPad target, icon and splash screen can be chosen in Player Settings.
• 3:4 and 4:3 aspect ratios can be used to prepare your game for iPad.
• Native plugins are supported in iPad Simulator.

Bug Fixes

• System.xml can now be used with iPhone Basic license.
• Fixed static batching to correctly treat multiple materials in the source meshes.

Known Issues

• Unity iPhone Remote does not work on iPad.
• Unity iPhone Remote does not support iPad resolution emulation in Unity iPhone Editor.
• Video playback is always portrait on iPad (possible workaround is to use rotated video).
• Audio playback is problematic in iPad Simulator (most probably iPad Simulator bug).
• Xcode shows a lot of harmless warnings.

iPhone 1.6

Note: a newer version of Unity iPhone has been released. Check out the current release notes to find out what's really new.

New features, improvements, and changes

New Features and Improvements

• Reduced iPhone player build size.
• Added Networking support.
• Added .NET 2.1 support via the Mono 2.6 runtime.
• Added HTTPS support for the WWW class.
• WWW class reimplemented using NSURLConnection API.
• Dramatically improved prefab handling.
• Slightly improved startup times of applications.
• Editor stability improved. Null references in Mono code are now handled better.
• Added support for native->managed SendMessage. Your plugins can "talk" to Unity now.
• Improved linker compatibility for iPhone OS 3.1 and 3.1.2 targets. No more annoying error messages in Xcode.
• System and System.Xml can now be used without stripping. Useful for Basic license owners.
• Implemented network stripping so you can reduce your app size if you don't use Networking.
• Improved compatibility with Xcode GDB debugger/instruments. Xcode profiler is supported now.
• Added labels for OS 3.1.3 and OS 3.2 in Player Settings. Deploy to the latest iPhone OS with Unity iPhone 1.6.
• Minor changes to the Player Settings interface.
• Updated documentation. Networking guides, .NET tips and much more have been added to the docs.

Bug Fixes

• Numerous documentation fixes and additions.
• Resolved prefab-related crashes and bugs. Overall stability and workflow experience is much better now.
• Re-parented prefabs with broken connections do not produce any error messages.
• Bulk prefab duplicating does not break any connections.
• Fixed tridimensional arrays crash.
• Application.dataPath to now include the application name.
• Fixed "Transform child has another father" issue.
• Fixed Xcode problem when customizing the build directory.
• About screen no longer shows "Educational license" for Unity iPhone Basic license owners.

Known Issues

• Unity iPhone Remote may still be unstable on Snow Leopard.
• GUI Layout may not work on iPhone.

iPhone 1.5

Examples, Assets, and Reference

• Introduced iPhone Standard Assets package.
• Heavily updated manual & reference documentation – check out the iPhone section in manual documentation – performance optimization tips, batching, new APIs etc.
• Prepared native code integration sample project – check Plugins manual page for download URL.
• Penelope Example Project and Tutorial created – see how to create touch-to-move, player relative, and camera relative character controls.

Perfromance Optimizations

• Improved Occlusion Culling – now uses less memory and culls more effectively.
• Updated Threaded main loop to give some room for OS events processing, if player is very CPU intensive.
• Introduced thread based main loop – now you can choose between NSTimer, Thread and OS event pump (CFRunLoop) methods. Thread method is set by default now.
• Lots of internal rendering loop optimizations.
• Optimized skinning using VFP coprocessor which is significantly faster than GPU skinning (Unity can skin up to 5Mverts/s now).
• Optimized animation of bone hierarchies.
• Optimized animation system to cope better with big numbers of Animation States.
• Improved performance for float arithmetics in Mono scripts.
• Improved script call performance when "Fast but no exceptions" optimization is on.
• Added 4 bone weights skinning path on VFP.
• Added 2 UVset support for 4 bone weights skinning path on VFP.
• Added 2 UVset support for 2 bone weights skinning path on VFP.
• Implemented alternative main loop (instead of NSTimer) which allows better CPU resource utilization and explicit control how much time OS spends processing events (enabled by default, can be disabled by setting #define USE_NSTIMER_FOR_MAIN_LOOP 1 in AppController.mm).

New Features and Improvements

• Added basic copy protection scheme. Use iPhoneUtils.isApplicationGenuine property to determine if DRM was removed.
• Application.OpenURL now available for Basic licenses too.
• Introduced Maximum Allowed Timestep setting in the Project Settings | Time which allows engine to skip FixedUpdates if frame-rate is low.
• Added native plugin support (advanced license feature). Just add custom attribute [DllImport("__Internal")] to your native implemented methods in C# and corresponding implementation to the XCode project.
• Exposed full-screen movie playback support to scripts (iPhoneUtils.PlayMovie/PlayMovieURL).
• Added support for GPS/location service (iPhoneSettings.StartLocationService / iPhoneInput.lastLocation).
• Exposed native iPhone keyboard to scripts (iPhoneKeyboard class).
• Implemented native iPhone keyboard input for TextField/PasswordField/TextArea GUI elements.
• Exposed all 4 screen orientations as iPhoneSettings.screenOrientation. iPhoneSettings.verticalOrientation is now deprecated.
• Added support for vibration (iPhoneUtils.Vibrate).
• Exposed number of properties via Editor Player Settings UI (including bundle version and UI interface orientation).
• Implemented support for up to 8 texture units in shaders for iPhone 3GS. Added iPhone 3GS emulation in the Editor.

Batching

• Automated support for static batching – just mark your objects as "Static" and they will be batched upon building the player or entering play mode in the Editor. No need for additional scripts.
• Implemented simulation of dynamic and static batching in the Editor. Now Stats window will display predicted number of draw calls and vertices as if run on iPhone.
• Introduced automatic batching for small (less than 300 vertices) dynamic objects if they share same material. Reduces OpenGLES draw-call overhead.
• Introduced static batching for objects of any size if they share same material and never change their transform node. Use CombineForStaticBatching script provided with Standard Assets to prepare your game objects for this type of batching.
• Updated static batching script to omit normals if they were not included in the original meshes, saves some memory.
• Improved static batching setup – it is not necessary to create additional GameObjects for statically batched geometry anymore, instead original GameObject renderer is patched. However you have to use renderer.worldToLocalMatrix/localToWorldMatrix while setting shader parameters instead of analogous methods in Transform component. Not complying with this requirement might lead to shading artifacts.
• Editor now spits warnings/errors if static batching or static batching scripts were used with Basic license.

Additional Improvements

• If touch has begun and ended during the same frame (in case of a very short tap), then Unity will delay end phase until the next frame so scripts can react to touch correctly.
• Improved GC heap management, now typical heap size should be 200-400 KB.
• Improved XCode append project functionality. Hidden folders now aren't removed from 'Classes' and 'Libraries' subfolders.
• NullReferenceExceptions now should work on OS 3.0 devices. (Just hit "continue" twice if debugger stops on it).
• Unity respects your XCode project now. It is not overwritten anymore by default. You can safely add new files, modify project itself or AppController.mm file, Unity will append its things as necessary. Note however that some folders like Libraries, Data, root project folder are always overwritten.
• Added splash screen and icon selection to the Project Settings | Player.
• Stripping levels order has been changed. New order is following: Disabled, Strip Assemblies, Strip ByteCode, Use micro mscorlib.
• All triangles are counted now, degenerate triangles are not omitted anymore in the Editor since they incur performance penalty on a real device (pre 3GS iPhones have no postTnL cache).
• iPod Touch 3rd generation device can be detected now.
• Removed iPhone unrelated properties from Project Settings.
• Vibration invoked in Editor will print debug message in Editor Log.
• Reimplemented iPhoneSettings.generation property. Now returns enum instead of a string and supports iPhone 3GS.
• Added hideInput property to iPhoneKeyboard class.
• Added "half"(4 out of 8 texture stages) of the iPhone 3GS emulation mode which works on nVidia cards.
• Improved visual appearance of the keyboard input.
• iPhone application display name property exposed in Project Settings | Player.
• Improved internal profiler stats. Added GC collection to total duration.
• Implemented iPhoneSettings.generation property which allows to query device generation.
• Increased default time to process events from 3ms to 7ms in AppController.mm. Improves responsiveness of touch/accelerometer input for some games, but might slightly reduce performance for other ones.
• Renamed "Override Audio" setting to "Override iPod Music" in Project Settings.
• Error message is shown in the editor if project being built for iPhone contains MovieTexture asset (instead of a cryptic run-time error).
• Added "Override Audio" setting to Project Settings | Player which forces iPod background music to be explicitly stopped on application start.
• Added internet reachability property: iPhoneSettings.internetReachability. Check this property before making WWW queries.
• Added "Done" button to close multi-line and numeric keyboards. Somewhat improved look&feel of keyboard's input field.
• Added culling time to internal profiler stats.
• Added garbage collector runs to internal profiler stats.
• Tweaked the splash screens.

Bug Fixes

• Fixed Touch.deltaTime to be reported correctly both at run-time and using UnityRemote.
• Fixed occasional halts in some very specific circumstances plus skinning involved.
• Fixed static batching scripts to use UV0 instead of UV1 if latter is not present.
• Fixed installer to keep standard Unity examples intact.
• Fixed svn leftovers in trampoline.
• Occlusion culling bug fixes.
• Fixed crash in RenderObjectSorter.
• Fixed incorrect rendering of scene when UIWindow is created before engine initialization.
• Fixed occasional mesh asset import crash when iPhone graphics emulation is turned on.
• Small keyboard fixes.
• Fixed license text.
• Fixed accidental appearing of device location query confirmation dialog.
• Fixed performance degradation issue with uncompressed audio.
• Fixed iPod music to be respected if started in the middle of the game.
• Fixed compressed music to start playing if iPod music was stopped in the middle of the game.
• Fixed OS X Snow Leopard crashbug.
• Fixed occasional black frame between splash screen and first scene being displayed.
• Fixed bug in rendering subsystem that limited texture units to 2 on iPhone 3GS which supports more than 2 units.
• Fixed crash in iPhoneSettings.isApplicationGenuine when using NSTimer based main loop.
• Projector now supports statically batched geometry too.
• Fixed occasional tearing on a projected textures using Projector component.
• Fixed Maya asset import when several objects has the same name.
• Fixed support for depth offset in shaders.
• Made various fixes to scripting references and documentation.
• Fixed crash if some objects were allocated before Unity starts.
• Made iPod background music to be respected on OS3.0.
• Improved WWW class connection failure handling.
• Fixed incorrect GUI clipping with GUI.BeginGroup.
• Fixed bug when a sound refused to start playing if any other sound was stopped during the same frame.
• Fixed bug when incorrect materials were set, if rendering via Graphics.DrawMesh API.
• Fixed scale issue with particles rendering in Orthographic projection.
• Fixed incorrect error message in the Editor if DOT3 was used.
• Uncompressed audio playback now works correctly after movie playback or external interruption (phone call, text message, alarm).
• Fixed automatic batching for skinned meshes.
• Fixed incorrect ordering of alpha-blended surfaces with automatic batching.
• Fixed some skinned meshes being unlit.
• Fixed iPhone emulation in the Editor incorrectly reporting that DOT3 is not being supported.
• Fixed number of FBX import related issues.
• Fixed infinite loop in case when an animation event callback is calling play/stop/change time on the same animation which triggered the event.
• Fixed audio crash by preventing AudioSource prefabs to be used without instantiation.
• Fixed line renderer crash if lit.
• Fixed wrong transparency issue with 16 bit textures.
• Fixed 16 bit textures to be used as is without decompression to 32 bit formats in memory.
• Fixed occasional monolinker crashes.
• Fixed support for Application.CaptureScreenshot.
• Fixed audio import dialog to show only related information for mp3/m4a files.
• Fixed skybox to be compatible with simple materials which do not define 6 planes.
• Fixed iPhoneTouch.position values in the Editor.
• Fixed setting volume for compressed audio.

iPhone 1.5.1

New Features and Improvements

• No more warnings about using Static property in Basic license.
• Added new "In App Purchases" section to documentation.
• Added AssetBundle export helper script to iPhoneStandardAssets.
• Improved support for latest XCode 3.2.
• XCode project now always defaults to "Device" target.
• Improved prefab handling.
• SDK version is now exposed in Player Settings in the Editor.
• Improved draw call batching emulation in the Editor.
• WWW class now support file:// protocol too.
• Introduced support for CADisplayLink on OS3.1 for faster main loops. However CADisplayLink is disabled by default as number of developers reported input lag in combination with CPU-demanding applications. Use with care!
• Updated UnityRemote default SDK to 3.0.
• Help->Release Notes loads Unity iPhone specific page now.
• Internet activation for Unity iPhone trial.

Bug Fixes

• Native APIs (NSGetEnviron and exc_server functions) are no longer used.
• Fixed project compatibility with Unity 2.6.
• Fixed AssetBundles support.
• Fixed compressed audio being silent after video playback on pre 3.x OS devices (case 285871).
• Fixed black screen occasionally appearing after splash screen (case 290495).
• Fixed Unitron occasionally renaming scripts.
• Fixed incorrect WWW stripping if used by external assemblies (case 282196).
• Fixed static batching failing on a certain mesh sizes (case 287300).
• Fixed dynamic draw call batching to correctly use vertex count as a threshold instead of a poly count.
• Fixed ShaderLab to work correctly when SubShader contains unsupported GPU programs – as an example standard specular shader was broken (case 250796).
• Fixed MBX emulation for point lights with attenuation (case 287359).
• Fixed additive projector included in iPhoneStandardAssets to correctly support MBX hardware.
• Disallowed cloning of texture assets if Get/Set Pixels was not turned on (case 287886).
• Fixed occasional harmless yet annoying error message in the CombineChildren script and in the static batching code.
• Fixed non-power-of-2 non-compressed texture warning (Case 298168).
• Fixed warnings and debug console spam if kAccelerometerFrequency is set to 0 (cases 291787, 291790).
• Fixed warnings in AppController.mm for pre 3.1SDKs.
• Added missing secondaryAxis property in ConfigurableJoint scripting API.
• Fixed bunch of small errors in scripting references.

Known Issues

• Importing Unity 2.6 projects with compressed meshes will give a warning message. It is recommended to turn mesh compression off in Unity 2.6 before opening project in Unity iPhone 1.5.1 for better visual quality.

iPhone 1.0.3

New Features and Improvements

• This release contains no new features.

Bug Fixes

• Fixed performance slow-down while using compressed audio on OS 3.0 devices.

iPhone 1.0.2

New Features and Improvements

• Texture memory is now freed once it has been submitted to OpenGLES on the device, reducing memory usage by 50%. The "Enable Get/SetPixels" flag in the Texture Import Settings lets you disable this feature on a per-texture basis in order to access the texture data from a script using GetPixel and friends
• Reduced memory footprint for uncompressed audio by 50%
• Improved iPhone script call optimization
• Removed unused parts of Mono runtime
• Reduced memory overhead while reading data from disk and slightly improved load times.
• Support for several predefined splash-screens (portrait/landscape) for Unity iPhone Basic. Just rename one of the splash-screens in the output directory to Default.png
• Exported audio session activation/deactivation functions to AppController.mm
• Added Scripting Reference code examples for iPhone specific APIs

Bug Fixes

• Fixed audio to play correctly after phone call / text message / alarm interruption occurs
• Fixed compressed audio occasionally refusing to play
• Fixed AudioSource.PlayOneShot to work correctly with compressed audio
• Fixed audio to respect Mute switch and background iPod music
• Fixed Pause function and time property for compressed audio clips
• Fixed OpenAL memory leak
• Fixed PhysX memory leaks
• Fixed Audio and Animation assets leaking while loading new scene
• Fixed a crash related to playing compressed audio in a sequence
• Fixed memory leak while updating Mesh geometry data
• Fixed several small memory leaks in rendering module
• Fixed asynchronous .NET sockets
• Fixed .NET threads
• Fixed cross thread boundary calling to the delegates
• Fixed UnityEngine.TextEditor stripping
• Fixed GUI slider stripping
• Fixed GUI scroll view stripping
• Fixed IndexOutOfRange exception checking
• Fixed Boo.Lang.dll stripping
• Fixed occasional crashes of AOT cross compiler

iPhone 1.0.1

New Features and Improvements

• Added support for compressed mp3/m4a audio playback. Note that iPhone hardware supports only one compressed audio clip at a time
• Improved performance of script to engine calls by an order of magnitude (e.g calling transform.localPosition is 300% faster). This optimization is disabled by default and should be enabled via Project Settings | Player | iPhone script call optimization property. Note that exception handling will not work correctly when this optimization is enabled
• Improved Mono runtime stability
• Improved gathering of referenced assemblies while building player
• OnApplicationQuit() callback gets called while quiting Unity player
• OnApplicationPause() callback gets called once Unity player becomes inactive
• Added support for Application.OpenURL
• Exposed UnityPause() function to ObjectiveC for better interoperability between custom code and Unity player
• Status bar is now hidden on startup
• Introduced support for explicitly defined bounding volume areas for occlusion culling
• Improved occlusion culling volume generation
• Made input in UnityRemote more reliable. All touch phases and accelerometer changes are guaranteed to reach the Editor
• Improved UnityRemote connectivity by exchanging echo packets with Editor to ensure that connection is valid
• Improved internal profiler statistics with various aspects of engine performance being displayed
• Internal profiler statististcs are disabled by default for better performance
• kFPS set to 60 by default to provide stable frame-rate

Bug Fixes

• Fixed PlayerPrefs bug preventing it to store persistent data
• Fixed memory leak when loading scenes
• Fixed Horizontal/Vertical slider crash
• Fixed occasional crash during Mono garbage collection
• Fixed crash in AOT cross compilation which subsequently left process hanging on in the background
• Fixed number of bytecode stripping bugs
• Fixed grahics related crash
• Worked around OpenAL bug which caused audio clips sometimes to stop playing
• Fixed trail and line renderers
• Fixed issue where WWW class preventing data to be sent immediately on 3G/Edge
• Fixed issue with transparent sorting
• Fixed default GUI skin failing to pass build step verification
• Fixed split screen support in the Editor
• Fixed AudioSource playback to respect AudioListener volume
• Fixed assert when skinned characters come into view
• Fixed Screen.width/height briefly reporting wrong values in the Editor
• Fixed bug where installer pops up old version warning