We do this with a combination of:

• Continuous Integration
• Automated Testing
• Code Hosting
• Code Reviews
• Manual Testing

I’ll talk about how we do the first four of those things here.

Continuous Integration

The Continuous Integration Server

Our builds and automated tests are all run by TeamCity.

We use TeamCity from JetBrains as our continuous integration solution.  One of the things we like best about TeamCity is that it has a very clear UI that gives the end user a good indication of the state of a project.  For testsuites, it’s easy to see at a glance whether the suite passes or fails and what tests are failing.  It can farm builds out to agents on Windows, OS X, and Linux, and keeps an extensive history of builds and tests, which are very useful when trying to figure out why a test is failing or whether there is something wrong with an agent.  Generally speaking, we are quite happy with the feature-set and also with the support we’ve received from JetBrains.

Our only real complaint now is regarding the web UI — it can still be slow to load at times (specifically, when loading a large project page that hasn’t been loaded for a while, or when opening the custom build run dialog when a lot of agents are attached).  It can also be difficult regarding managing multiple branch projects, as there is currently no way to synchronize changes between branches that are copies of each other.  However, the projects are stored in XML, and the schema is not complicated, so I have written a tool to do this instead by modifying the XML directly.

The Build Farm

TeamCity farms builds out to a distributed build farm of between 40 and 50 machines.

Along with TeamCity, we have a build farm of approximately 45 machines, known as build agents.  Most of these are virtual machines running Windows, Mac OS X, and Linux.  We also have a few physical machines used for graphics tests, because testing graphics functionality requires a level of GPU manipulation that we could not achieve with virtual machines.  Our virtual build agents are virtualized with VMWare Workstation on Linux hosts, using a combination of Apple and non-Apple hardware.

The reason for choosing virtual machines, despite the performance hit it gives us, is that virtualization allows us to easily maintain the system — instead of updating 45 machines separately, we update the template virtual machine image for a given operating system, then copy it to the live buildservers.  It also allows us to make every agent appear to be the same hardware-wise, even if they are running on different types of host hardware.  This is important because as we add more build agents, they will be running on different generations of hardware, and for the purposes of testing, we need them to all appear the same.

Automated Testing

TeamCity provides a very clear interface for seeing the status of test suites.

We have several automated test suites that we run on a regular basis.  These are used, along with manual testing, as a metric for how stable our mainline codebase is, as well as when a feature branch is stable enough to be merged back into trunk.  We currently have four types of test suites:

• Unit Tests — these test the correctness of individual functions / small bits of functionality in the code, but they do not test high-level features of the product.  These are used by developers, but not by our continuous integration server.
• Graphics Tests — these work by building a Unity project that renders a set of static scenes.  The project is then run on the target platform (desktop, console, or mobile), and screenshots of each scene are saved.  We then compare the saved screenshots against a set of “known good” screenshots.  If the difference is greater than a certain amount, we assert that the test has “failed”.
• Functional Tests — these work by launching one instance of the editor or player, and testing various aspects of its functionality.
• Integration Tests — these are the most high level tests.  They work by launching an instance of the editor or player, testing a particular action or series of actions, and shutting down the editor or player and going on to the next test.

Our integration tests are executed by our continuous integration server as NUnit tests.  TeamCity can run MSBuild projects directly, and we have a script that runs them with Mono’s Xbuild on Mac OS X.  We developed our own framework for running the graphics tests.

Our regression rig tells us if anything has changed in the playback of previously-recorded content.

We also have a regression rig that we developed ourselves.  The regression rig, similar to the graphics tests, compares content played in Unity against previously recorded content, and checks for regressions.  This is a good way to catch high-level regressions (for example audio having become bit-shifted).

Our test suites are always being expanded, and, along with our regression rig, they have helped us catch a number of regressions and bugs.

Code Hosting and Reviews

Like many software companies, Unity Technologies has run through a few different version control systems.  In the beginning, there was no version control.  Eventually the first Unity Ninjas began using CVS, and eventually Subversion. About a year ago, we started to investigate distributed version control systems and eventually settled on Mercurial.  Now all of our source code is versioned in Mercurial, except for our public Mono, MonoDevelop, and Boo-related repositories on GitHub.

Why Mercurial?

Well, we had a few requirements.  The first was that the version control system work with our continuous integration server, which is TeamCity, so we started off considering Git, Mercurial, and Bazaar, and Perforce.  We also wanted something distributed because we have developers working in several different locations, and we also work on multiple platforms.  A distributed system allows our developers around the globe to interact with the remote server less frequently, and it also allows all of us to easily test our changes on multiple local machines without having to share changes that potentially break some other platform with each other.  We also wanted to be able to do feature development in branches and merge them back together successfully.  So we were left with Git, Mercurial, and Bazaar.  We spent some time evaluating these three systems.  We were interested in:

1. A simple, easy to use and understand command-line interface
2. Good GUI tools for the system on OS X and Windows
3. A good code review tool that works well with the system.

We also wanted a system that we felt had a lot of momentum — an ecosystem that is growing and developing around it.  After a few weeks of testing, we eventually decided on Mercurial because:

1. It was substantially more simple to learn and use than Git
2. It had good GUI tools for both Windows (TortoiseHg) and Mac (SourceTree, and now TortoiseHg)
3. It had a couple of different options for large-scale code review tools
4. It had a good-sized user-base (which is growing), a regular development cycle, and seemed to be well-adopted by both open-source and and commercial projects

Another very big win for Mercurial is that it was the only DVCS (at the time, at least) that had even attempted to handle the issue of large binaries in the repository.  This was done through a few different publicly-available extensions to Mercurial.  Distributed version control systems, by nature, don’t lend themselves well to codebases with a lot of large binaries, so we knew we would need some system that can cooperate with the version control system to store the large binaries outside of the repository, but still let us version them in some way.  Not having to develop our own system completely from scratch was a really big win.

How to Host Mercurial and What to Use for Code Reviews?

After we decided on Mercurial, we needed to figure out how to host it and how we would review code.  With this switch, we also wanted to implement a new development policy.  Up until this point, we had always worked with just one central copy of the codebase, except for when we branched for release.  This led to something almost always being broken, which had a serious effect on productivity.  We wanted to be able to easily do feature development in branches; perform peer code reviews, build, and test verification on the branch; then merge it back into the mainline repository once it is complete.  The goal is that trunk is always in a releasable, or nearly releasable, state.

A Code Review in Kiln.

We looked at a few different code review systems, and eventually settled on Kiln from Fog Creek Software.  Many people already know that we have used FogBugz as our issue tracking system for a while now.  While FogBugz has some room for improvement (specifically, it doesn’t work very well as a public-facing bug tracker), it has done a pretty good job of serving our needs, and we have a really large amount of data in the system.  At this point, we would need a pretty compelling reason to put in the effort to move all of that data to a new system.  Kiln is a Mercurial code hosting system that interfaces with FogBugz and provides nice web-browsing of the repositories, code reviews on a per-changeset basis with one or more reviewers, and a server-side implementation of a Mercurial extension that handles large binaries. We have had some ups and downs with Kiln, mostly with regards to performance.  Our repository size, which is about 1.6 GB with a clean working copy, and has several fairly large binaries, as well as our number of concurrent developers, about 65 and growing, and our build farm, another 45 or so machines, seem to have pushed it to its limits performance-wise.  The self-hosted version of Kiln is currently not built with scalability to large teams (with large repositories) in mind, which results in very slow clones & pushes when there is heavy load. Hopefully, this will get resolved in the future. We’re not sure what our own future is with Kiln, but I will say that its feature set is quite nice, and it has allowed us to move to our desired development model of feature development in branches rather than in mainline.  Beware that it is written in .NET and does not run on Mono, so if you want to consider Kiln, you will need to run a Windows server.  I can say, however, that the Fog Creek support staff has spent countless hours trying to help us work through our various issues with Kiln.

Conclusion

Building and testing for so many platforms is a really difficult task — especially as our development team is rapidly growing, and we find ourselves putting strains on infrastructure and processes in areas we didn’t expect.  These tools and processes are fundamental to how the development team gets things done here at Unity.

What elements make water?

Hydrogen & Oxygen

in Unity?

There are many different types of water you can create or use from prefabs. To take advantage of the latest water effects and scripts I will be concentrating on the Water4ExampleSimple assets which are essentially a couple of 3D meshes representing your water surface, with:

• WaterTile script
• Water shader

An empty object indicating the world space placement with:

• A Water script which exposes the colours, normal texture and main parameters for the effect
• A reflection script
• An optional lighting script for specular effects
• An optional displacement script

How can I make some water?

The simplest way is to drag the prefab into your scene, and assign your custom mesh:

• Assets > Import Package > Water (pro only)
• In the project window open the  Standard Assets > Water (Pro only) folder
• Open up Water4 folder
• Drag the Water4Example (Simple) Prefab into your scene
• Position approximately where you need it
• Select one of  the tile meshes, go to the mesh component in the inspector > select the round target icon on the right and choose your mesh (must be in your project)
• Rotate the Water4ExampleSimple parent node 90 degrees, if your mesh comes in at the wrong angle (this can be caused when you export from a 3D app with a different co-ordinate system to Unity)
• Place your mesh by moving the parent node
• Remove the second tile mesh

Settings

Once you have your mesh as water you can begin to play with the settings. Select your Water4ExampleSimple node, and check the parameters in the inspector.

Water Base

Planar Reflection

This script is for enabling/disabling realtime planar reflections. Reflections are claculated in relation to the height of the parent mesh that has this script attached to. So the local Y transform of child meshes should be 0. Here you can also enable the reflections to include (or not) the skybox.

Specular Lighting

You can adjust the specular power from here and drag’n'drop any transform to indicate a specular light source. This can be your directional light transform or any other game object (doesn’t need to be a light).

Gerstner Displace

Here you can adjust the settings for the wave generation created by the Gerstner waves generation algorithm.

Water art tips

• Go and check out some actual water – its always wise to get some visual ref for what you are trying to do. Make a video if you can.
• Water absorbs red light from the spectrum reflecting back more green and blue rays, in additions to sky, which gives water the impression of being Blue in colour so:
  • You can’t make your surface blue (and you probably shouldn’t)  but if you use green and blue colours on the surfaces below the water such as a pool you can help with the illusion.
  • (I guess this is why Pool designers use green/blue/turquoise tiles).
  • The darker the blue, the deeper water appears – you can use a darker colour on the bottom and tint the refraction darker.

• Moderate the effects, subtlety can help suspend disbelief, be sure to experiment but think about moderating:
  • Scrolling speed of normals
  • Reflection
  • Refraction
  • Fresnel and Normal strengths
  • Displacement

• One useful tip is to turn practically everything off e.g. set sliders to zero and then build up the effects to get the desired impact.
• If you have a convex mesh (such as water fall/pool lip) add poly detail to the curve to help the water ‘bend’.

Next time > Water 4 Advanced is the same tech but with foam and depth extinction.

Export

Edit

Finalise

It may be a worthy read both for artists and programmers, as we discuss the possibilities of some unusual special effects and their technical side.

Get it while it’s fresh: Special Effects with Depth (14MB pdf)

Yours,

Kuba and Ole

Unity supports textured 3D models from a variety of programs or sources. This short guide has been put together by games artists with developers at Unity, to help you create assets that work better and more efficiently in your Unity project. This will be incorporated into the documentation in due course

Scale & Units

• Set your system and project units  for your software to work consistently with Unity e.g. Metric.
  • Working to scale can be important for both lighting and physics simulation;
  • Be aware for example; Max system unit default is inches and Maya is centimetres.
  • Unity has different scaling for FBX and 3D application files on import, check FBX import scale setting in Inspector.
  • If in doubt export a metre cube with your scene to match in Unity.

• Animation frame rate defaults can be different in packages, is a good idea to set consistently across your pipeline – e.g. 30fps for example.

Files & Objects

• Name objects in your scene sensibly and uniquely – this can help you locate and troubleshoot specific meshes in your project:
• Avoid special characters *()?”£$n  etc.
• Use simple but descriptive names for both objects and files (allow for duplication later).
• Keep your hierarchies as simple as you can.
• With big projects in your 3D application, consider having a working file outside your Unity project directory – this can often avert time consuming updates and importing unnecessary data.

Sensibly named objects help you find stuff quickly

Mesh

• Build with an efficient topology – use polygons only where you need them.
• Optimise your geometry if it has too many polygons – many character models will need to be intelligently optimised or even rebuilt by an artist esp if sourced/built from:
  • 3D capture data
  • Poser
  • Zbrush
  • Other hi density Nurbs/Patch models designed for render

• Evenly spaced polygons in buildings, landscape and architecture where you can afford them, will help spread lighting and avoid awkward kinks.
• Avoid really long thin triangles

Stairway to framerate heaven

The method you use to construct objects can have a massive affect on the number of polygons, especially when not optimised. Observe the same shape mesh : 156 triangles (right) vs 726 (left). 726 may not sound like a great deal of polygons, but if this is used 40 times in a level, you will really start to see the savings. A good rule of thumb is often to start simple and add detail where needed. It’s always easier to add polygon than take them away.

Textures

Textures are more efficient and don’t need rescaling at build time if authored to specific texture sizes – e.g a power of two – up to 4096×4096 pixels, e.g. 512×512 or 256×1024 etc.  (2048×2048 is the highest on many graphics cards/platforms) there is lots of expertise online for creating good textures, but some of these guidelines can help you get the most efficient results from your project:

• Working with a Hi-res source file outside your unity project can be good working practice (such as a PSD or Gimp file – you can always downsize from source but not the other way round).
• Use the texture resolution output you require in your scene (e.g. save a copy – such as a 256×256 optimised PNG or a TGA file for example) you can make a judgement based on where the texture will be seen and where it is mapped.
• Store your output texture files together in your Unity project for example: \Assets\textures
• Make sure your 3D working file is referring to the same textures for consistency when you save/export.
• Make use of the available space in your texture, but be aware of different materials requiring different parts of the same texture can end up using loading that texture multiple times.
• For alpha (cutout) and elements that may require different shaders, separate the  textures. E.g. the single texture below (left) has been replaced by 3 smaller textures below (right)

1 texture (left) vs 3 textures (right)

• Make use of tiling textures (which seamlessly repeat) then you can use better resolution repeating over space.
• Remove easily noticeable repeating elements from your bitmap, and be careful with contrast – if you want to add details use decals and objects to break up the repeats.

Tiling textures ftw

• Unity takes care of compression for the output platform, so unless your source is already a JPG of the correct resolution it’s better to use a lossless format for your textures.
• When creating a texture page from photographs, reduce the page to individual modular sections that can repeat, e.g. you don’t need 12 of the same windows using up texture space. That way you can have more pixel detail for that one window.

Do you need ALL those windows?

Materials

• Organise and name the materials in your scene – this way you can find and edit your materials in Unity more easily when they’ve imported
• You can choose to create materials in Unity from either:
  • <modelname>-< material name> or:
  • <texture name> – make sure you are aware of which you want.
• Settings for materials in your native package will not all be imported to unity:
  • Diffuse Colour, Diffuse texture and Names are usually supported
  • Shader model, specular, normal, other secondary textures and substance material settings will not be recognised/imported (coming in 3.5)

Import/Export

Unity can use two types of files: Saved 3D application files and Exported 3D formats – which you decide to use can be quite important:

Saved application files

Unity can import, through conversion:  Max, Maya, Blender, Cinema4D, Modo, Lightwave & cheetah3D files, e.g. .MAX, .MB, .MA etc.

http://unity3d.com/support/documentation/Manual/HOWTO-importObject.html

Advantages:

• Quick iteration process (save and Unity updates)
• Simple initially

Disadvantages:

• A licensed copy of that software must be installed on all machines using the Unity project
• Files can become bloated with unnecessary data
• Big files can slow Unity updates
• Less Validation – harder to troubleshoot problems

Exported 3D formats

Unity can also read FBX, OBJ, 3DS, DAE & DXF files – for a general export guide you can refer here:

http://unity3d.com/support/documentation/Manual/HOWTO-exportFBX.html

Advantages:

• Only export the data you need
• Verify your data (re-import into 3D package) before Unity
• Generally smaller files
• Encourages modular approach

Disadvantages:

• Can be slower pipeline or prototyping and iterations
• Easier to lose track of versions between source(working file) and game data (exported FBX)

Characters & Animation

Coming soon!

At the latest London Unity User Group, the evening kicked off with a beginner talk by Jasper Stocker, and was followed by ‘Open Mic’ talks by myself – demoing a quick Space Shooter demo I made in Unity – and LUUG regular Quickfingers, showing off a game he made for recent Ludum Dare 48 game jam. The headline act was Richard Fine, who gave an excellent talk on creating large game worlds in Unity.

As usual I do my best to capture the LUUG meets for others to catch up with, this time  however I only had a single camera to work with, and no screen capture – ability.. but here is the footage anyway! enjoy folks..

Quickfingers – Making AWOL for Ludum Dare

Richard Fine – Making Large Game Worlds

Part One

;

Part Two

For more info on London Unity Usergroup, including the next meetup, see the meetup site – http://www.meetup.com/London-Unity-Usergroup/

This page gives an overview of the default Unity Hotkeys

Ahem.

So yeah, a bunch of us were at SIGGRAPH 2011 in lovely Vancouver, doing talks, meeting people and going to super interesting sessions. Me & ReJ did a long technical session about optimizing graphics for mobile platforms. GPU architectures, shader optimization details, case studies from actual Unity games and so on.

Here it is: Fast Mobile Shaders (17MB pdf).

Enjoy!

The recent release of 3.4 brought many awesome new features to Unity.. with it came a ton of new assets and optimizations to the Unity Asset Store! Here’s a quick look at recent and notable additions to the store.  If you haven’t been to the Unity Asset Store before, you’ll find it inside Unity– just launch Unity and select Window > Asset Store.  It’s an incredibly convenient way to find quality, ready-to-use, royalty-free models, scripts, sound effects, music and editor extensions right in your workspace.  It couldn’t be easier!

Addicted to Substances

Airstream Substance demo project

A mind-blowingly useful new feature in Unity 3.4 is the integration of the dynamic texture generation system, the Allegorithmic Substance engine, directly inside Unity.  If you’re not yet familiar with Substances, you should check them out, as they’re the most efficient way to pack tons of complex textures (with diffuse, specular, normal maps and more) into a very, very small footprint!  You can actually adjust an Allegorithmic Substance’s parameters in run-time with code or even animation keyframes, to create living, dynamic textures which can change over time in your game.   To get started, you’ll need to pick up a pre-existing, incredibly-customizable substance from the Asset Store, which contains the basic procedural patterns for your textures.  Use them like any material on your mesh objects and adjust the parameters as you like!

You will find over 500 pre-made Allegorithmic Substance on the Asset Store, ranging from commonly used textures including metals, woods, sci-fi and fabric, to vivid, organic and alien textures.   Allegorithmic’s system is so addictive, if you’re not careful you might become a substance abuser!  Allegorithmic’s substances can be found in the Materials & Textures section of the Asset Store.  It’s a great way to beef up your project.

We have a free 18-substance pack on the Asset Store as well as a two great example projects to get you going.

Rain{one}

Rain{one} AI behavior tree by Rival{theory}

Popular on the Asset Store this month is the very brainy AI system, Rain{one} from the Los Alamos thinktank, Rival{theory}.  It’s the easiest way to give in-game characters core AI capabilities such as the ability to sense the world, navigate, and create complex behaviors through goal or task based logic. Features include…

1. Pathfinding, Pathfollowing and Path Graph Generation
2. Behavior Trees and Goal Oriented Behaviors
3. Movement & Locomotion
4. Environment Sensors
5. One-Click AI Configuration

It’s a great way to give your zombies some braaaains.

Nature!

Nature Pack

Imagine.. the serenity of soaring trees, blooming wildflowers, the graceful curves of a fern, clouds, the majesty of a stony cliff. A verdant, rolling landscape.  There are many places to find such natural beauty… like Yosemite, the Swiss Alps, and the Unity Asset Store.  Quite popular this month is the comprehensive and well-crafted Nature Pack, which has over 30 trees and bushes, stones, natural textures and more, all prepared for use with Unity’s Terrain System.  You’ll also find mushrooms, wildflowers and trees of many species.

Free tunes from the folks at AudioDraft

The good people at the music crowd-sourcing company, AudioDraft, have recently added three packages of high-production, cost-free and royalty free music for the Asset Store.  Check out their Arcade, Orchestral, and Space themed music packs!

Improved Performance and UI

You might have noticed that the Asset Store has a new look, with a category tree hierarchy system, making it a cinch to find what you’re looking for, or just to browse casually.  There’s also speed optimization and purchase data caching for an easier shopping experience.

Content creators making a bundle!

Last month marked the most recent payout to content creators on the Asset Store, with a couple of our sellers having each earned tens of thousands of dollars.  Distributing and selling content on the Asset Store is a great way to put your skills to work, get your vision out to the Unity community, and making money! We’re always looking for great new content to put on the Asset Store.  We’re on the lookout for great models, complete game projects, editor extensions and tools, script libraries, audio and more.  If you’ve made something awesome, please send it our way!

What are Substance Materials?

Substance materials are procedurally generated assets, from technology developed by Allegorithmic. A ’substance’  is basically a set of maps, defining a whole material with all channels: Diffuse, Normal, Specular, Bump, etc. 3DS Max and  Maya have substance support for rendering, but now with Unity implementation we can make use of them in real-time applications.

Why use Substance materials?

There are a number of reasons to use of procedural materials:

• Dynamically updateable in game
• Resolution independent
• Animation supported
• Tiny file size
• Really fast to create textures, especially bricks, tiles and other tileable surfaces, that are otherwise time consuming to generate from photographic source
• Fast to duplicate and create library of unique material
• They are cool

Where do I get Substance Materials?

The Asset Store in unity (Window > Asset Store) includes free and paid substance packages available to browse.

How do I use them?

To customise a substance material and apply in Unity follow these steps:

• Import or create a mesh onto which you want to apply materials;

• Make sure it is UV’d evenly, or as desired – use a checkerboard or dummy material (Currently unity cannot import subtance materials assigned in external packages)
• Create a fairly even topology, polygons spread to rule out kinks etc.
• Apply relevant smoothing as required

• Check FBX import settings for the Mesh, Select  Materials Generation ‘Per Material’  esp if using multiple materials per object
• Drag object into hierarchy or viewport and save scene
• Find Substance material asset you want to use (the square substance icons)

• Apply to object by dragging directly onto the mesh in the viewport or with multi material meshes to the element (shown below)

• Edit the parameters for your material instances;

• Randomise seed to create variations on the patterns
• Adjust sliders for other parameters such as colour, dirt amount, normal strength or whatever your substance has exposed in the inspector
• Change shader if required to add reflections and other fx

• View the results in the viewport – can be useful to create shader spheres in your scene for representative lighting

Dear Unity iOS Developers,

Unfortunately, many (and probably all) Unity iOS applications built with iOS SDK 4.3 are crashing during the App Store Review process while still running successfully on developer’s devices. We have contacted Apple regarding this issue and received confirmation that this is of highest priority to them. Our iOS team is working on a solution as well, but due to complex nature of the problem it will take longer than expected to properly resolve. A currently known workaround is to keep using iOS SDK 4.2.

Many users reported that applications built with Xcode 3.2.5 + iOS SDK 4.2 successfully pass the Apple App Store review process currently. OS SDK 4.2 is not publicly available on the iOS Developer site anymore, but it still can be downloaded via direct link. We want to assure you that building final applications with iOS SDK 4.2 provides all the features the Unity iOS run-time supports and is proven to work fine with devices running older generation iOS (3.x-4.2.x) as well as the newer devices running iOS 4.3.x (like iPad 2).

Please feel free to contact us if you have issues releasing your application to the App Store.

Regards,
The Unity Team

Since then, we have spent many hours listening to your stories in forums, analyzing your builds, and trying out some ideas. We finally nailed the issue: iOS SDK 4.3 introduced a tiny problem with the native code linker improperly calculating how much code should be protected by the AppStore code protection system. The problem exposes itself only when AppStore protection is applied to the application.

Recently, a few forum users reported about successful submissions to the AppStore using iOS SDK 4.3. This led us to the solution (we would like to say big thanks to forum users “susantio” and “ratrodstudio”!). Our investigation of their projects revealed common use of the special linker flag “-all_load” (which is required by some 3rd party ObjC plugins). Using this flag forces iOS SDK 4.3 native linker to properly calculate protected code size and so it solves the problem.

Unity 3.4, which is just around the corner, will include this flag by default. If you can’t wait, you can try it sooner by applying few changes to your Xcode project by hand.

Instructions how to add this flag to your release build when using Xcode 3.2.6 (SDK 4.3):

1. Open your project in Xcode.
2. In the Xcode menu select Project->Edit Active Target.
3. In the Configuration drop down select “Release”.
4. In the Search field type “linker”.
5. Find the field named “Other Linker Flags” and double click on it.

6. Click “+” and add “-all_load”.

7. Clean all targets.

Instructions how to add this flag to your release build when using Xcode 4/4.0.2 (SDK 4.3):

1. Open your project in Xcode.
2. In the Project Navigator click on your project.
3. On the next pane select “Unity-iPhone” under TARGETS.
4. On the next pane select “Build Settings”.
5. In the Search field type “linker”.
6. Find the field named “Other Linker Flags” and double click on “Release” configuration near it.

7. Click “+” and add “-all_load”.

8. Clean all targets.
9. Make a distribution build by clicking “Product”->”Build For”->”Build For Archiving” (Note: don’t use Product->Build, because it will make “debug” build by default and won’t include “-all_load” flag).

We have received multiple confirmations from forum users that this helped them get into AppStore using iOS SDK 4.3. Also we are sharing all our findings with Apple, and we hope that this will help to get some fix included into SDK update.

As always please feel free to contact us if you have issues releasing your application to the AppStore or any platform.

We plan to release light probes with Unity 3.5; all the other effects can already be achieved in Unity!

We launched Unity Asset Store during the Unite keynote on November 10th and to celebrate our 3 months anniversary and over 10,000 registered users, we’ve made a small but important addition to the store. You can now create links to packages in the store and post them on the web.

Creating the links is simple. Open the Asset Store window inside Unity and find the package you want to link to, then click on one of the three sharing buttons. The Facebook and Twitter buttons require little explanation. Simply click on one of them to blast a message to your favorite social network. The link button on the left can be used in case you simply want the raw URL for your website or anywhere you can post a link.

We think this is a great way for developers to promote and create interest around their products. It will also be extremely useful for sharing recommendations with others. For instance, here’s a list of the top 5 most downloaded packages on the Asset Store this week:

1. iTween Visual Editor By David Koontz
2. iTween By Pixelplacement
3. C# game examples By M2H
4. Road and Path Tool By Six Times Nothing
5. River Tool By Six Times Nothing

Note that you need to have Unity 3.2 installed in order to open the Asset Store from these links. Upgrade or install it now if you haven’t already done so.

1. You made a good looking game with Unity for any platform;
2. You have a high quality game video that you share with us;
3. You don’t mind that we only use the video fragments we like best.

For reference, here is the video that we assembled last spring:

If you can help us out and are interested in the opportunity to see your game at the Unity booth, post a link to your video in the comments. We’ll contact you for more details if we are able to use it.

Oh, and the timing…

We’ve started working on our GDC showreel, so early submitters have a much higher chance to see their videos added to the reel.

Thanks in advance!

Our shader ninja has been hard at work, forging a great new set of effects with a host of exposed settings to allow full customization of your Unity project.

In the scene we have a bunch of awesome new and upgraded effects including:

Vignetting
Depth Of Field (Bokeh)
Bloom And Flares
Sun Shafts

Anyway, enough talk… lets see what you will receive in the 3.2 update!

Love,
The Demo Team

Senior QA Specialist Samantha Kalman and the Demo Team have put together a quick introduction of how easy it is to set up your games to use Occlusion Culling in Unity 3.0. We first introduced our own Occlusion Culling system in Unity iPhone 1.0 because we felt it to be an important feature for getting the most out of the platform. We have now stepped it up by seamlessly integrating the leading industry standard Umbra Occlusion Culling technology into Unity and making it available across all platforms that Unity supports.

Enjoy!

In this short video Will Goldstone shows some of the benefits of the new deferred rendering path in Unity 3.0 such as being able to have dozens of lights on screen at the same time without a performance hit as well as using advanced image effects that utilize the same depth and normal textures as deferred rendering.

And stayed tuned for the Occlusion Culling video… we promise it’s almost ready

First up is design3, a subscription based site created by Noesis Interactive, who create professional courseware for Universities. They have over 200 Unity specific videos and more on the way. Whether an educator, a student, or a business, you can check out their free trial and see if it works for you.

Next up we have Will Goldstone’s Unity 3D Student. This is a great concept, he doesn’t provide the standard “here is a huge tutorial about how to make X kind of game” but rather has micro tutorials that teach fundamental concepts — and then challenges that require the student to piece together what they’ve learned.

And finally, the Tornado Twins have begun to serve up their tutorials on their Unity Prefabs site. The first few chapters of each series are free; if you like them then you can purchase the remaining chapters for that series.

Senior QA Specialist Samantha Kalman and Demo Team Artist Roald Høyer-Hansen have put together a great introduction of how Beast has been seamlessly integrated into Unity. We hope you enjoy the preview video and are looking forward to all the beautiful scenes people will create using Unity 3′s new lightmapping features!

Enjoy!

In this video Will Goldstone gives us a tour of just some of the new Asset Management features in Unity 3. These include Scene View searching by name and type, the new Object Selector offering vast improvements over the previous method of selecting and assigning Assets, and Asset Labels which greatly speeds up searching and categorizing large projects.

PS- Nicholas would like to personally apologize for the inconsistent GUI scheme in the Object Selector at the time of this recording… it’s still a work in progress after all

Demoteam out.

This is Ole from the (in)famous Unity Demo Team ™. I would like to show you a preview of some of our new handcrafted and ready-to-use Image Effects we are planning to release with Unity 3.0.

Let’s look at some examples.

For this screenshot, i stacked together a total of three different Effects. The new Bloom effect (which will feature layer masks in addition to the traditional alpha channel based glow intensity), the Sun shafts effect and the new image based Lens flare Effect (here in all its horizontal glory).

Speaking of lens flares, we are finally able to create “New Star Trek” style scenes in Unity, as can be seen here:

Skybox based sun shafts are doing a nice job on many outdoor scenes while being a surprisingly cheap image effect. The new Skyboxes we will provide in the new 3.0 Standard Assets will all come with a predefined alpha channel to work nicely with sun shafts:

We also included a new Depth of field image effect:

There will also be some not-so-obvious effects that might find some love: Crease shading, a more complex color correction using Unity’s animation curves, unsharp mask for contrast enhancement, a new outline image effect and more.
Let’s put those outlines on our Lightbulb scene. We will get this:

The Outline effect is a also a nice base for creating more complex NPR (Non-photorealistic rendering) image effects, such as sketch/scribble shading, halftoning, etc.

Let’s have a look at what we can achieve with our (old and dying) Island demo. We can e.g. turn this…

into high art such as this…

or even this…

just by blurring the edges and using it as a foundation for an image based shading. You can supply different scribble textures (or just a dot texture if you like old printers a lot).

That’s it from me. Demoteam out.

I recently traveled over to Gotland (an island off the coast of east Sweden) to give a lecture to some of the happy games development students out there. As part of the lecture I talked briefly about the Animation View. That part of the talk is now being made available to everyone though the magic of video tutorials!

Head over to resources page to check it out. The videos are also available on our Vimeo page.

No animals were harmed in the making of this tutorial... much

I have only really scratched the surface with the short demonstrations in these videos. I really look forward to seeing what the community ends up creating with this fundamentally “game changing” feature, seriously… you can animate your variables AND call functions from within your animation, how awesome is that!? 

Anyway, before my brain melts due to the near incomprehensible possibilities that the Animation View offers, I’d like to note that I would really appreciate feedback on the video and on the Animation View itself.