Procedural mesh generation - problem with normals.

I’m trying to make mesh figure generated procedurally but some triangles clearly have broken normals. What is weird, everything is okay during play in editor:
[35129-normal+normals.jpg*_|35129]

But after build game and run it from exe file,has become a strange light on some triangles.
[35130-broken+normals.jpg*_|35130]

On pictures we have exactly same place, but we can see, that some triangles on lava mesh ignore light.

My mesh needs to have normal maps. It of course require tangents so to achieve that, I’m using script avaible at Computing Tangent Space Basis Vectors for an Arbitrary Mesh and converted to javascript by nootz (http://forum.unity3d.com/threads/how-to-calculate-mesh-tangents.38984/):

/*
Derived from
Lengyel, Eric. “Computing Tangent Space Basis Vectors for an Arbitrary Mesh”. Terathon Software 3D Graphics Library, 2001.
http://www.terathon.com/code/tangent.html
*/


static function TangentSolver(theMesh : Mesh)
{
    vertexCount = theMesh.vertexCount;
    vertices = theMesh.vertices;
    normals = theMesh.normals;
    texcoords = theMesh.uv;
    triangles = theMesh.triangles;
    triangleCount = triangles.length/3;
    tangents = new Vector4[vertexCount];
    tan1 = new Vector3[vertexCount];
    tan2 = new Vector3[vertexCount];
    tri = 0;
    for ( i = 0; i < (triangleCount); i++)
    {
        i1 = triangles[tri];
        i2 = triangles[tri+1];
        i3 = triangles[tri+2];
       
        v1 = vertices[i1];
        v2 = vertices[i2];
        v3 = vertices[i3];
       
        w1 = texcoords[i1];
        w2 = texcoords[i2];
        w3 = texcoords[i3];
       
        x1 = v2.x - v1.x;
        x2 = v3.x - v1.x;
        y1 = v2.y - v1.y;
        y2 = v3.y - v1.y;
        z1 = v2.z - v1.z;
        z2 = v3.z - v1.z;
       
        s1 = w2.x - w1.x;
        s2 = w3.x - w1.x;
        t1 = w2.y - w1.y;
        t2 = w3.y - w1.y;
       
        r = 1.0 / (s1 * t2 - s2 * t1);
        sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
        tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
       
        tan1[i1] += sdir;
        tan1[i2] += sdir;
        tan1[i3] += sdir;
       
        tan2[i1] += tdir;
        tan2[i2] += tdir;
        tan2[i3] += tdir;
       
        tri += 3;
    }
   
    for (i = 0; i < (vertexCount); i++)
    {
        n = normals*;*

t = tan1*;*

// Gram-Schmidt orthogonalize
Vector3.OrthoNormalize( n, t );

tangents*.x = t.x;*
tangents*.y = t.y;*
tangents*.z = t.z;*

// Calculate handedness
tangents_.w = ( Vector3.Dot(Vector3.Cross(n, t), tan2*) < 0.0 ) ? -1.0 : 1.0;
}
theMesh.tangents = tangents;
return theMesh;
}
Turning off that script fix the problem with broken normals. So there is my question: where lies the problem in attached script and is there other possibility to calculate mesh tangents?

_*

I found the answer. I’am not sure if it is correct, but I assignet to every mesh tangents Vector4(0, 1, 0, 1).

Not sure if it helps, but here is a script that calculates tangents:

using UnityEngine;
using System.Collections;

public class CalculateTangents : MonoBehaviour
{
	
	public static void CalculateMeshTangents(Mesh mesh)
	{
		//speed up math by copying the mesh arrays
		int[] triangles = mesh.triangles;
		Vector3[] vertices = mesh.vertices;
		Vector2[] uv = mesh.uv;
		Vector3[] normals = mesh.normals;
		
		//variable definitions
		int triangleCount = triangles.Length;
		int vertexCount = vertices.Length;
		
		Vector3[] tan1 = new Vector3[vertexCount];
		Vector3[] tan2 = new Vector3[vertexCount];
		
		Vector4[] tangents = new Vector4[vertexCount];
		
		for (long a = 0; a < triangleCount; a += 3)
		{
			long i1 = triangles[a + 0];
			long i2 = triangles[a + 1];
			long i3 = triangles[a + 2];
			
			Vector3 v1 = vertices[i1];
			Vector3 v2 = vertices[i2];
			Vector3 v3 = vertices[i3];
			
			Vector2 w1 = uv[i1];
			Vector2 w2 = uv[i2];
			Vector2 w3 = uv[i3];
			
			float x1 = v2.x - v1.x;
			float x2 = v3.x - v1.x;
			float y1 = v2.y - v1.y;
			float y2 = v3.y - v1.y;
			float z1 = v2.z - v1.z;
			float z2 = v3.z - v1.z;
			
			float s1 = w2.x - w1.x;
			float s2 = w3.x - w1.x;
			float t1 = w2.y - w1.y;
			float t2 = w3.y - w1.y;
			
			//float r = 1.0f / (s1 * t2 - s2 * t1);
			float div = s1 * t2 - s2 * t1;
			float r = div == 0.0f ? 0.0f : 1.0f / div;
			
			Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
			Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
			
			tan1[i1] += sdir;
			tan1[i2] += sdir;
			tan1[i3] += sdir;
			
			tan2[i1] += tdir;
			tan2[i2] += tdir;
			tan2[i3] += tdir;
		}
		
		
		for (long a = 0; a < vertexCount; ++a)
		{
			Vector3 n = normals[a];
			Vector3 t = tan1[a];
			
			//Vector3 tmp = (t - n * Vector3.Dot(n, t)).normalized;
			//tangents[a] = new Vector4(tmp.x, tmp.y, tmp.z);
			Vector3.OrthoNormalize(ref n, ref t);
			tangents[a].x = t.x;
			tangents[a].y = t.y;
			tangents[a].z = t.z;
			
			tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), tan2[a]) < 0.0f) ? -1.0f : 1.0f;
		}
		
		mesh.tangents = tangents;
	}
}