Learn how to use C# Static Members to share data between scenes.

In this Unity Cookie Quick Tip, we’ll take a look at sharing data between scenes using C# Static Members in a Scene Manager script. I use a global scene manager to share data and between scenes that doesn’t need to be saved to disk. By using Static members, I can call my scene manager script without having to have a reference to it. The idea is that I am using my scene manager as Singleton. My scene manager is only instanced once and provides utility functions for managing global aspects of my game.

In this video, I will show how to commit user-defined data to the Scene Manager and recall that data in a separate scene. I also wrap the Application.LoadLevel into the Scene Manager to create a helper function for loading scenes.

Scene Manager Script

using UnityEngine;
using System.Collections;

public class SceneManager : MonoBehaviour {

	#region STATIC VARIABLES
	public static string userData;
	#endregion

	//STATIC FUNCTION
	public static void OpenScene(string sceneToLoad)
	{
		Application.LoadLevel(sceneToLoad);
	}
}

Creating Custom Pivots in Unity

In this Unity Cookie quick tip, we’ll take a look at creating custom pivots. You can’t directly manipulate pivots in Unity. You can either choose to transform an object using it’s center or pivot, but you can’t change the pivot. Most of the time this is not an issue as you’ll be working with 3D content from your 3D application and Unity will respect the pivot position as imported from the 3D object. However, there are times when you are working with native Unity objects where you need to adjust or create a new pivot.

Using a parent pivot object will allow you to not only create a custom pivot, but will also allow you to place a transformation at a higher level such as when you might need to separate the rotation and position transformations. This is common in camera follow scripts.

Drawing Gizmos

In the video, I also talk about helper scripts that use the Gizmo class. I use the Gizmo class often in my project to create helper editor objects when building my games. Here is the code mentioned in the video to draw a simple wireframe sphere in the editor.

using UnityEngine;
using System.Collections;

public class Gizmo : MonoBehaviour {

	public float gizmoSize = .75f;
	public Color gizmoColor = Color.yellow;

	void OnDrawGizmos()
	{
		Gizmos.color = gizmoColor;
		Gizmos.DrawWireSphere(transform.position, gizmoSize);
	}
}

Learn to animate a line draw using the Line Renderer Component

I recently worked on a project where I needed to draw a line from one game object to another. That is easy enough to do using the Line Renderer component, however, I wanted to animate the line renderer moving from point A to point B. In this video quick tip, I show you how I accomplished this effect with just a small bit of scripting.

Finding a position along a line

The key to animating the line is to calculate a position along the known distance of the line and feed this updated position to the line renderer component’s “SetPosition” method. You do this in the Update function.

To calculate the postion along the line, I used the following steps.

1. Get the unit vector in the desired direction
2. Multiply by the desired length
3. Add the starting point.

In order to actually animate the line, I increment a variable that is interpolated between 0 and the known distance of the line. The interpolation is handled by using Mathf.Lerp.

Technical Quick Tip: Combining multiple materials into a single draw call

It’s time to get down and dirty with some scripting in Unity.

In this Technical Unity Cookie Quick Tip, I take you through the process of using scripting to combine multiple materials and vertex colors into a single material with a single draw call. We’ll be starting with the mesh.color script available here from Unity.

This technique is based around changing the vertex colors with scripting, and then taking those colors into the shader, now this technique is not just for changing colors, we can also use it to change textures, and pass variables to the shader on a per object basis while all objects keep the same material and therefore within a single draw call.

Referenced Tutorials in the Tip

• Surface Shader Series
• Intro to Shader Writing

Got questions?

Feel free to leave them below or see you on the forums!

Tower Defense Tutorial: Part 9 AI Tanks

In this video, we will take our new found knowledge of AI Pathfinding and apply it to real, in-game Tanks! This means AI units that move along the ground, and intelligently dodge obstacles, relentlessly marching toward your base.  Luckily, we will also cover upgrading your defenses- setting up projectiles and turrets for this new enemy.

What is covered in this tutorial:

• Applying AI to an in-game enemy
• Upgrading projectile, enemy, and turret scripts to all be class-based
• Creating spawns for the ground units
• Efficiently rebuilding the AI Grid and Re-Pathing all units as needed

 This tutorial uses the “A” Pathfinding Project

• Download “A” Pathfinding Project
• View Getting started tutorial on the “A” Pathfinding project.

Tower Defense Tutorial: Part 8 – AI Pathfinding

This tutorial will focus almost exclusively on setting up a fully-functional AI Pathfinding solution for our Tower Defense game! This paves the way for our ground-based attackers, allowing them to dynamically maneuver around turrets, even as you place them. Of course, AI Pathfinding can be useful for many other projects, so give this one your full attention!

What is covered in this tutorial:

• Downloading and importing the “A* Pathfinding Project”
• Setting up a grid-based A* Graph
• Creating a script to intelligently Path your Units
• Using the Character Controller component to move units along the AI Path

 This tutorial uses the “A” Pathfinding Project

• Download “A” Pathfinding Project
• View Getting started tutorial on the “A” Pathfinding project.

Learn to write surface shaders in Unity in this complete tutorial series.

In this Unity tutorial series we will be giving you an introduction shader scripting, showing you how to write your our own surface shaders for your Unity game.

This text tutorial is accompanied by a complete video. I recommend watching the video and referring to the text as reference.

Be sure to read the tutorial carefully, and post any questions you may have if you get stuck, as there is a lot to cover. I will be using some examples from the Unity shader reference found here:
http://docs.unity3d.com/Documentation/Components/SL-SurfaceShaderExamples.html

My goal is to help you understand how shaders work and how you can write your own shaders from scratch in Unity.

NOTE: This tutorial requires very basic knowledge of scripting such as variables and functions. If you have no scripting experience I recommend you first watch our Introduction to Scripting tutorial in the getting started section.

In part 6 we added cubemap reflections to our shader, now we will boost our silhouettes by adding rim lighting

Part 7 – Adding rim lighting to our Unity surface shaders

The last part of writing surface shaders that I want to teach you before we get into writing our own lighting models, is the Rim lighting.

• Rim lighting can be used without writing a lighting model and is really easy to use.
• We are going to make use of the dot product in this shader, which allows us to get a value of 0 to 1 based on the angle.
• We can use viewDir as the input angle to get some cool results.

For this one we will be using the viewDir to have the value based on the angle we are looking from. So first let’s break down what we want to do.

• For rim lighting, we want to have some light glow around the edges of the model.
• Now viewDir is 1 when we are looking straight at it, and 0 when it is perpendicular.
  - If we used this as the emission it would be bright at the center and diffuse at the rim. The opposite of what we want.
  - So we will need the inverse of that.

Let’s write the shader.

Shader "unityCookie/Rim Lighting" {
	Properties {
		_MainTex ("Diffuse Texture", 2D) = "white" {}
		_BumpTex ("Normal Map", 2D) = "bump" {}
		_RimColor ("Rim Color", Color) = (1,1,1,1) //The color tint of our rim light
		_RimPower ("Rim Power", Range(0.1,10)) = 3.0 //The power of our rim, note that we start from 0.1 as we don't really want 0.
	}
	Subshader {
		Tags { "RenderType" = "Opaque"}
		CGPROGRAM
		#pragma surface surf Lambert
		struct Input {
			float2 uv_MainTex;
			float2 uv_BumpTex;
			float3 viewDir; //We want to get the viewing angle
		};
		sampler2D _MainTex;
		sampler2D _BumpTex;
		float4 _RimColor;
		float _RimPower;
		void surf (Input IN, inout SurfaceOutput o) {
			o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
			o.Normal = UnpackNormal (tex2D (_BumpTex, IN.uv_BumpTex));
			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), o.Normal)); // we take the view angle and place it in a 0-1 half value
			o.Emission = _RimColor.rgb * pow (rim, _RimPower); // we take our rim output (0-1) and take it to the power of our rim power.
		}
		ENDCG
	}
	Fallback "Diffuse"
}

Ok so there is an interesting line in there

half rim = 1.0 – saturate(dot (normalize(IN.viewDir), o.Normal));

So let’s break this up.

• saturate() – This makes sure that the value stays between -1 and 1, as we don’t want it to go outside of the valid color ranges.
• dot() – This takes the dot product of our view angle with the normal angle and returns a value from 0-1
• normalize() – This removes any values less than 0, as when the normals are facing away from you they go into negatives which we don’t normally want.

And finally we have the pow() function, which takes the first number to the power of the second number. (2 times three to the power of 4 = 2 * (3*3*3*3) )

So that’s our last shader for this series, in the next part we will take a look at debugging and optimizing our shaders.

Learn to write surface shaders in Unity in this complete tutorial series.

In this Unity tutorial series we will be giving you an introduction shader scripting, showing you how to write your our own surface shaders for your Unity game.

This text tutorial is accompanied by a complete video. I recommend watching the video and referring to the text as reference.

Be sure to read the tutorial carefully, and post any questions you may have if you get stuck, as there is a lot to cover. I will be using some examples from the Unity shader reference found here:
http://docs.unity3d.com/Documentation/Components/SL-SurfaceShaderExamples.html

My goal is to help you understand how shaders work and how you can write your own shaders from scratch in Unity.

NOTE: This tutorial requires very basic knowledge of scripting such as variables and functions. If you have no scripting experience I recommend you first watch our Introduction to Scripting tutorial in the getting started section.

In part 5 we took a look at adding specularity to our shaders, now let’s take that a step further and add cubemap reflections.

Part 6 – Adding cubemap reflections to our Unity surface shaders

Instead of specularity, perhaps you want an object to be reflective such as a window, plastic or a teapot. This is where cubemaps come into play.

So let’s take our lambert diffuse shader and add some reflections:

Shader "unityCookie/Cubemap Reflection" {
	Properties {
		_MainTex ("Diffuse Texture", 2D) = "white" {}
		_Cube ("Cube Map", CUBE) = "" {} //A property so we can add the cube map in Unity
	}
	Subshader {
		Tags { "RenderType" = "Opaque"}
		CGPROGRAM
		#pragma surface surf Lambert
		struct Input {
			float2 uv_MainTex;
			float3 worldRefl; //This is a pre-defined variable in unity for world space reflections
		};
		sampler2D _MainTex;
		samplerCUBE _Cube; //We sample the cubemap so we can use it
		void surf (Input IN, inout SurfaceOutput o) {
			o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
			o.Emission = texCUBE (_Cube, IN.worldRefl).rgb;
		}
		ENDCG
	}
	Fallback "Diffuse"
}

We introduce four new commands.

• worldRefl; This is a built in variable which allows you to display an image in world space, making it appear as if the material is reflecting.
• samplerCUBE  This is like the sampler2D, but is specific to sampling cube maps, this tells Unity the map is a cubemap.
• o.Emission  This makes the surface emit this color, which is important for lighting and refelctions. It does not mean that the surface is actually emitting light.
• texCUBE  Like tex2D, but instead of a flat image we want to treat this like a box.

So this is great, but what about the normal map? How do we get that to work? Well normal maps are a bit more tricky, we need to use the INTERNAL_DATA to get the WorldReflectionVector of our normal. Sounds confusing, but it isn’t much more to add to our code:

Shader "unityCookie/Bumped Cubemap Reflection" {
	Properties {
		_MainTex ("Diffuse Texture", 2D) = "white" {}
		_BumpTex ("Normal Map", 2D) = "bump" {}
		_Cube ("Cube Map", CUBE) = "" {}
	}
	Subshader {
		Tags { "RenderType" = "Opaque"}
		CGPROGRAM
		#pragma surface surf Lambert
		struct Input {
			float2 uv_MainTex;
			float2 uv_BumpTex;
			float3 worldRefl; //We don't use this down below, but it is used in the INTERNAL_DATA module so we still need to specify we want it.
			INTERNAL_DATA // Notice how this is in all caps, this is telling Unity we want to use the internal data module, we won't get into what that is but just know that it's got some cool stuff in it.
		};
		sampler2D _MainTex;
		sampler2D _BumpTex;
		samplerCUBE _Cube;
		void surf (Input IN, inout SurfaceOutput o) {
			o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
			o.Normal = UnpackNormal (tex2D (_BumpTex, IN.uv_BumpTex));
			o.Emission = texCUBE (_Cube, WorldReflectionVector( IN, o.Normal)).rgb; //We take the world reflection vector from our normals, and we simply give it all our inputs
		}
		ENDCG
	}
	Fallback "Diffuse"
}

Okay so hopefully that’s not too confusing. The WorldReflectionVector is a built in command that takes our normals and world space reflection, then uses the internal data to figure out what the reflection should be according to the normals.

Whew, this stuff get’s tricky doesn’t it? But don’t worry, once you understand it, this stuff will be a piece of cake.

In the next step we will move on to rim lighting.

Learn to write surface shaders in Unity in this complete tutorial series.

In this Unity tutorial series we will be giving you an introduction shader scripting, showing you how to write your our own surface shaders for your Unity game.

This text tutorial is accompanied by a complete video. I recommend watching the video and referring to the text as reference.

Be sure to read the tutorial carefully, and post any questions you may have if you get stuck, as there is a lot to cover. I will be using some examples from the Unity shader reference found here:
http://docs.unity3d.com/Documentation/Components/SL-SurfaceShaderExamples.html

My goal is to help you understand how shaders work and how you can write your own shaders from scratch in Unity.

NOTE: This tutorial requires very basic knowledge of scripting such as variables and functions. If you have no scripting experience I recommend you first watch our Introduction to Scripting tutorial in the getting started section.

In part 4 we covered how to add normal maps to our shaders, now let’s take a look at adding specularity

Part 5 – Adding specularity to our Unity surface shaders

Our shader is looking great, but it is still using lambert shading. Let’s add some specular highlights to our shader and while we’re at it we will use some awesome properties to control the specularity.

First, before we can use specularity we need to change our lighting model. Currently we are using ‘Lambert’, to get specularity we need ‘BlinnPhong’, this is a predefined lighting model in the Lighting.cginc file in your Unity installation. (You can actually add lighting models to this cginc file, but that’s a topic for another day.)

So what properties does a specular shader add to the mix?

Well we have three new ones:

• _SpecColor – This is used in the lighting model itself to control the tint of the specular highlights. As it’s already being called in the lighting model, we don’t need to do anything else with it.
• o.Specular – This is the specular power, or how soft the falloff is on the specularity.
• o.Gloss – If you want to use an image to control where the specular highlights will show, this is where it is output. You can think of this as a black and white image to cut out areas of specularity.

So let’s apply specularity to our shader:

Shader "unityCookie/Bumped Specular" {
	Properties {
		_MainTex ("Diffuse Texture", 2D) = "white" {}
		_BumpTex ("Normal Map", 2D) = "bump" {}
		_SpecColor ("Specular Color", Color) = (1,1,1,1) //This passes a color to the BlinnPhong lighting model
		_SpecPower ("Specular Power", Range(0, 2)) = 0.5 //How strong our specular highlight it, notice how I have the range going to 2 to allow for some really sharp highlights
	}
	Subshader {
		Tags { "RenderType" = "Opaque"}
		CGPROGRAM
		#pragma surface surf BlinnPhong //We are now using the BlinnPhong lighting model
		struct Input {
			float2 uv_MainTex;
			float2 uv_BumpTex;
		};
		sampler2D _MainTex;
		sampler2D _BumpTex;
		float4 _SpecPower; //We define the _SpecPower as a float4 (4 floating variables for RGBA)
		void surf (Input IN, inout SurfaceOutput o) {
			fixed4 tex = tex2D (_MainTex, IN.uv_MainTex); //We define our texture as a fixed4 so we can extract the alpha to use as a gloss map
			o.Albedo = tex.rgb
			o.Normal = UnpackNormal (tex2D (_BumpTex, IN.uv_BumpTex));
			o.Specular = _SpecPower; //We use the spec power to control the intensity of our specularity
			o.Gloss = tex.a; //We use the alpha channel of our image to control where we want specularity.
		}
		ENDCG
	}
	Fallback "Diffuse"
}

Cool, so most of this should make sense, notice how we defined our _SpecPower with the sampler2D’s, This is where all properties go.

Next we have this one:

o.Gloss = tex.a;

We are using the alpha channel of our image to define the specular highlights. This means we don’t need a third image to control specularity.

You should be familiar with using spec maps by now, but if not, they are a black and white image, where the black cuts out the specularity to make it look more Lambert. this helps add an extra level of detail to the shader.

Next we will go in add take a look at cubemap reflections…

Tower Defense Tutorial: Part 7- Upgrading Turrets

No Tower Defense game is complete without up-gradable structures! This tutorial will setup your game for upgrades, and also lay some groundwork for purchasing of other items such as inventory, etc. Best of all, we will delve just a bit into “extending” from base classes. This is a technique you will find useful in many, many cases, and very simple to use.

What is covered in this tutorial:

• Creating a new “Upgrade Structure” GUI Panel
• Creating multiple levels of each Structure
• Using a Base Class, and Extending it with other scripts
• Creating a generic function to handle cost-checking when purchasing