// Add - Remove points in inspector
var linePoints:Vector3[];
// Proposed material : VectorLine
var myMat:Material;
var line : VectorLine;
function Start ()
{
	//Define the line, I found a width of 4.0 to be satisfacatory
	line = new VectorLine("Line", linePoints, myMat, 4.0, LineType.Continuous);
	// Draw the line
	Vector.DrawLine3DAuto(line, transform);
}

function Update()
{
	//This line forces the line to Update
	// and places it at (0,0,0) of local space of gameObject
	Vector.DrawLine3D(line, transform);
}

The second script, CustomEditorIppoLine1.js deals with the manipulation of the line points in Scene view and drawing of a line in it.

@CustomEditor( IppoLine1 )

class CustomEditorIppoLine1 extends Editor
{
	//Those Vector3 will define the points through which the line will pass in Scene view
	var positions : Vector3[];
	//This allows to do stuff in Scene view
	function OnSceneGUI()
	{
		Handles.color = Color.white;
		positions = new Vector3[target.linePoints.Length];
		var i :int =0;
		for(var item:Vector3 in target.linePoints )
		{
			// itemWorld is the position in world space of the FreeMoveHandle
			var itemWorld:Vector3 = Handles.FreeMoveHandle( target.transform.TransformPoint(item), Quaternion.identity, 0.2, Vector3.zero, Handles.RectangleCap);
			// move the linePoint[x] to the itemWorld position, translated in local space
			item = target.transform.InverseTransformPoint(itemWorld);
			Handles.DotCap(0, itemWorld, Quaternion.identity, 0.1);
			positions[i] = itemWorld;
			++i;
		}

		if (GUI.changed)
		{
			EditorUtility.SetDirty (target);
		}
		//Draw line in Scene view
		Handles.DrawAAPolyLine( 0.1, positions);
	}
}

Usage: Create a new project. Add VectrosityDemos_Unity3.unitypackage in it.
Create one folder called Editor and place CustomEditorIppoLine1.js in it. Add IppoLine1.js in your project too.
Make a new scene, add a new GameObject, place it at 0,0,0, name it (say) Line1, add IppoLine1.js to it.
Select the Line1 in the Hierarchy. In the Inspector, below the IppoLine1(script) select VectorLine as the Material.
On the left of LinePoints there is a small arrow. Click it. Set size to (say) 2. Set Element 0 x as -1 and Element 1 x as 1.
Now you will notice that in the scene view 2 little squared appear on both sides of the game Object. Drag them around.
Those define the begining and the end of the line. If you align the scene view with the camera view, what you see in the scene
will be identical with what you will see in runtime.
To add points, set size (as mentioned before) to 3 e.t.c. The trick is that the new points can be dragged out by selecting in the scene the last point or by setting manually their value in the Elements section.
I hope you will find these scripts useful.

var myMat:Material;
function Start () {
	// Make Vector2 array; in this case we just use 2 elements...
	var linePoints = [Vector2(0, Random.Range(0, Screen.height)),				// ...one on the left side of the screen somewhere
					  Vector2(Screen.width-1, Random.Range(0, Screen.height))];	// ...and one on the right

	// Changed null to myMat so we can choose a material in the inspector, width to 4.0 from 2.0.
	// Method signature: VectorLine (name : String, points : Vector2[] or Vector3[], material : Material, lineWidth : float, lineType : LineType = LineType.Discrete, joins : Joins = Joins.None)
	var line = new VectorLine("Line", linePoints, myMat, 4.0);

	// Draw the line
	Vector.DrawLine(line);
}

Now assign in the Inspector the material called VectorLine in the MyMat slot.
Save scene, press play and you havea nice, anti-aliased line
If you like this kind of lines, make sure that you use the VectorLine material.

Well, to blend what is in front with what is in back you should have something in back to blend with It is necessary to schedule somehow the rendering so opaque objects are rendered first and transparent after (so they have what to blend with). This page discusses the rendering order and this page discusses the blending options. Building on the previous example, we will perform the following changes in the Subshader section of the code

SubShader
{
        // This tells GPU how to blend the model with the rest
        //  of the scene, taking into account texture's
	Blend SrcAlpha OneMinusSrcAlpha
        // This tells GPU to render the shader after the opaque
        //  Geometry is drawn.
	Tags {"Queue" = "Transparent" }
	Pass
        {...}

So the complete code of the shader will be :

Shader "simple_Transparent_Shader"
{
	Properties
	{
	       // This allows to choose the texture from the Editor
	       _MainTex ("Base (RGB)", 2D) = "white" {}
	}
	SubShader
	{
		// This tells GPU how to blend the model with the rest
		//  of the scene, taking into account texture's
		Blend SrcAlpha OneMinusSrcAlpha
		// This tells GPU to render the shader after the opaque
		//  Geometry is drawn.
		Tags {"Queue" = "Transparent" }
		Pass
		{
		GLSLPROGRAM
		#ifdef VERTEX

		// varying is a special type of variable in glsl
		//  that lets you pass data from the Vertex to
		//  the Fragment shader
		varying vec2 the_uv;

		void main()
		{
		  gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

		  // Access the first texture unit and retrieve the texture coordinates
		  // that correspond to the uv coordinates of the given vertice
		  the_uv = gl_MultiTexCoord0.st;
		}
		#endif

		#ifdef FRAGMENT
		// Receive texture data from Unity Editor
		uniform sampler2D _MainTex;

		// Receive data from the Vertex to
		//  the Fragment shader
		varying vec2 the_uv;

		void main()
		{
			// The pixel color will correspond
			//  to the uv coords of the texture
			//  for the given vertice, retrieved
			//  by the Vertex shader through varying vec2 the_uv

			gl_FragColor = texture2D(_MainTex, the_uv);
		}
		#endif
		ENDGLSL
		}
	}
}

The answer seems trivial. Look it up in the docs, right here. Only that it gives an error :

BCE0022: Cannot convert ‘Object’ to ‘UnityEngine.Transform’.

After some search in the forums, in the Unity answers and #unity3d I found a solution (and spend 1 hour): I post it so you do not have to face the same frustration.

function Start()
{
	var myTrans:Transform[]  = gameObject.GetComponentsInChildren.() as Transform[];

	for (var child : Transform in myTrans )
	{
		//Do your stuff
	}

}

The above code will give you back all the children of a gameObject, regardless their nesting level.
Hope this helps

The first thing to do is to add an option to select a texture from Inspector view. To do so, we will modify the Properties code from the previous post. It will become

Properties
{
       // This allows to choose the texture from the Editor
       _MainTex ("Base (RGB)", 2D) = "white" {}
}

Ok,now if we select the shader in the inspector, we can choose a texture. The necessary info to display a texture is the texture itself and uv coordinates of each vertice. To inform the shader about the relation between texture coordinates and vertices uv we will change the Vertex shader code as follows :

#ifdef VERTEX

// varying is a special type of variable in glsl
//  that lets you pass data from the Vertex to
//  the Fragment shader
varying vec2 the_uv;

void main()
{
  gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

  // Access the first texture unit and retrieve the texture coordinates
  // that correspond to the uv coordinates of the given vertice
  the_uv = gl_MultiTexCoord0.st;
}
#endif

Now we should pass the texture and the texture coordinates to the Fragment shader. Modify the Fragmentshader as follows :

#ifdef FRAGMENT
// Receive texture data from Unity Editor
uniform sampler2D _MainTex;

// Receive data from the Vertex to
//  the Fragment shader
varying vec2 the_uv;

void main()
{
	// The pixel color will correspond
	//  to the uv coords of the texture
	//  for the given vertice, retrieved
	//  by the
	gl_FragColor = texture2D(_MainTex, the_uv);
}
#endif

So the complete code of the shader will be :

Shader "simple_Texture_Shader"
{
	Properties
	{
	       // This allows to choose the texture from the Editor
	       _MainTex ("Base (RGB)", 2D) = "white" {}
	}
	SubShader
	{
		Tags { "Queue" = "Geometry" }
		Pass
		{
		GLSLPROGRAM
		#ifdef VERTEX

		// varying is a special type of variable in glsl
		//  that lets you pass data from the Vertex to
		//  the Fragment shader
		varying vec2 the_uv;

		void main()
		{
		  gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

		  // Access the first texture unit and retrieve the texture coordinates
		  // that correspond to the uv coordinates of the given vertice
		  the_uv = gl_MultiTexCoord0.st;
		}
		#endif

		#ifdef FRAGMENT
		// Receive texture data from Unity Editor
		uniform sampler2D _MainTex;

		// Receive data from the Vertex to
		//  the Fragment shader
		varying vec2 the_uv;

		void main()
		{
			// The pixel color will correspond
			//  to the uv coords of the texture
			//  for the given vertice, retrieved
			//  by the Vertex shader through varying vec2 the_uv
			gl_FragColor = texture2D(_MainTex, the_uv);
		}
		#endif
		ENDGLSL
		}
	}
}

And that is all ! References from the first part still apply.

The first thing to do is to add an option to select a color from Inspector view. To do so, we will modify the Properties code from the previous post. It will become

Properties
{
       // This allows to choose the color from the Editor
       _Color ("Main Color", Color) = (1,0.5,0.5,1)
}

Ok,now if we select the shader in the inspector, we can choose a color. To pass this color in the shader we will change the fragment code as follows :

#ifdef FRAGMENT
	// This is a way to pass the data from the Unity Editor to the shader, via uniforms
	uniform vec4 _Color ;
	void main()
	{
	   gl_FragColor = _Color;
	}
#endif

So the complete code of the shader will be :

Shader "simple_Color_Shader"
{
	Properties
	{
	       // This allows to choose the color from the Editor
	       _Color ("Main Color", Color) = (1,0.5,0.5,1)
	}
	SubShader
	{
		Tags { "Queue" = "Geometry" }
		Pass
		{
		GLSLPROGRAM
		#ifdef VERTEX
			void main()
			{
			   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
			}
		#endif  

		#ifdef FRAGMENT
			// This is a way to pass the data from the Unity Editor to the shader, via uniforms
			uniform vec4 _Color ;
			void main()
			{
			   gl_FragColor = _Color;
			}
		#endif
		ENDGLSL
		}
	}
}

And that is all ! References from the first part still apply.

There are two types of shaders that GLSL ES 2.0 supports : Vertex and Fragment. Other types ( e.g Geometry shaders ) are not supported. The Vertex shader might get some input (more on that later) and should output at least gl_Position. A minimum Vertex shader is

void main()
{
    // Each vertex position on screen ( window ) space ( = gl_Position ) is calculated
    //   by multiplying the vertex position in the World space ( = gl_Vertex )
    //   with the MVP matrix ( = gl_ModelViewProjectionMatrix ).
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

The Fragment shader might get some input and should output at least gl_FragColor. A minimum Fragment shader is

void main()
{
    // For every pixel on the screen that belongs to this object
    //   paint the pixel red.
    gl_FragColor = vec4 (1.0, 0.0, 0.0, 1.0);
}

To use the above shaders in a unity shader, the template is

Shader "Shader name"
{
        Properties
        {
             //Fill any properties
        }
          SubShader
          {
                 Tags { "Queue" = "Geometry" }
                 Pass
                  {
                     GLSLPROGRAM
                     #ifdef VERTEX
                         // Add Vertex shader code here
                     #endif  

                     #ifdef FRAGMENT
                         // Add Fragment shader code here
                     #endif
                     ENDGLSL
                   }
           }
}

So a simple shader that displays the object in red is

Shader "simple_Red_Shader"
{
    Properties
    {        

    }
    SubShader
    {
        Tags { "Queue" = "Geometry" }
        Pass
            {
                GLSLPROGRAM
                #ifdef VERTEX
                void main()
                {
                   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
                }
                #endif  

                #ifdef FRAGMENT
                void main()
                {
                   gl_FragColor = vec4 (1.0, 0.0, 0.0, 1.0);
                }
                #endif
                ENDGLSL
            }
     }
}

In following posts, I ‘ll show how to create and access shader’s properties ( ie color, texture, etc ) from Unity Script and how to access Unity’s built-in values from UnityCG.glslinc.

Reference

As an example, 1000 plays ( someone played your game = 1 play ) gives approx 3 dollars. If your share is 35%, you get approx 1 dollar. To make 1000 dollars, you should target to 1.000.000 plays and above. Another source of revenue are weekly and monthly contests, with prices that vary from 250 – 1500 $. For more info check here. This month,  Step Sequencer is a Unity app that does well, so you could consider upvoting it !

As a tip, try to polish as possible the first minute of gameplay of your app. Kongregate users take fancy menus and polished graphics as a standard to consider playing a game. Another thing is that you should be aware that the publicity “window” that Kongregate provides is quite narrow, so if your game does not have many plays in the first days, it will be “buried” under another 41.000 games   So plan well the first impression, because it can make a difference. Also, Kongregate promotes games via placing them in the front page and creating “badges” for them. All those result in more plays -> more revenue.

The profit may seems small, but I think Kongregate is a good chance for someone to “wet” his feet in game development. You can submit games made with Unity free, you get user feedback which can help you remodel your project. That said, my current profits from Kongregate are 0.60 euros I hope that a next version of my game Thyella will do better !

Union gathers unity 3d games, converts them for the platform and makes them available as a bundle. Indies get 80% of the profits their game makes. As I see it, it is a nice deal, since it allows entering in a market  that was closed and profiting from this.

Here are some links that can help you familiarize with Union.

• A video explaining what union is about.
• Union -related posts from Unity blogs.
• Union page, here you can find more info and submit your project.

1. Union
2. Kongragate
3. Wooglie
4. Dime Rocker
5. Steam
6. Iphone app store
7. Mac app store
8. Make your own site and sell your game through that.
9. Find a sponsor that will promote its product through your game

In next posts I will write some thoughts and experiences with the above options.