public Vector3[] GetSourceVerts(MegaModifierTarget target)
    {
        if (VertsSource)
        {
            VertsSource = false;
            return(target.verts);
        }

        return(target.sverts);
    }
    public Vector3[] GetSourceVerts(MegaModifierTarget target)
    {
        if (VertsSource)
        {
            VertsSource = false;
            return(target.verts);
        }

        return(target.sverts);
        //return UpdateMesh < 1 ? verts : sverts;
    }
    public void SetMesh(MegaModifierTarget target, ref Vector3[] _verts)
    {
        if ((dirtyChannels & MegaModChannel.Verts) != 0)
        {
            target.mesh.vertices = _verts;              // mesh.vertices = GetVerts(true);
        }
        if ((dirtyChannels & MegaModChannel.UV) != 0)
        {
            target.mesh.uv = suvs;              //GetUVs(true);
        }
        if (recalcnorms)
        {
            target.mesh.RecalculateNormals();
        }

        if (recalcTangents)
        {
            BuildTangents(target);
        }

        if (recalcbounds)
        {
            target.mesh.RecalculateBounds();
        }

        if (recalcCollider)
        {
            if (target.meshCol == null)
            {
                target.meshCol = GetComponent <MeshCollider>();
            }

            if (target.meshCol != null)
            {
                target.meshCol.sharedMesh = null;
                target.meshCol.sharedMesh = target.mesh;
                //bool con = meshCol.convex;
                //meshCol.convex = con;
            }
        }
    }
    // Need to put bbox into modcontext not use modifier one
    void Start()
    {
        Transform[] objs = (Transform[])gameObject.GetComponentsInChildren <Transform>(true);

        targets = new List <MegaModifierTarget>(objs.Length);

        for (int i = 0; i < objs.Length; i++)
        {
            MegaModifierTarget target = new MegaModifierTarget();
            target.go = objs[i].gameObject;

            Mesh ms = GetMesh(target.go);

            if (ms != null)
            {
                target.cachedMesh = (Mesh)Mesh.Instantiate(ms);
            }

            targets.Add(target);
        }

        GroupReStart1(false);
    }
    public override void OnInspectorGUI()
    {
        MegaModifyGroup mod = (MegaModifyGroup)target;

        //EditorGUIUtility.LookLikeInspector();
        MegaModifiers.GlobalDisplay = EditorGUILayout.Toggle("GlobalDisplayGizmos", MegaModifiers.GlobalDisplay);
        mod.Enabled     = EditorGUILayout.Toggle("Enabled", mod.Enabled);
        mod.recalcnorms = EditorGUILayout.Toggle("Recalc Normals", mod.recalcnorms);
        MegaNormalMethod method = mod.NormalMethod;

        mod.NormalMethod   = (MegaNormalMethod)EditorGUILayout.EnumPopup("Normal Method", mod.NormalMethod);
        mod.recalcbounds   = EditorGUILayout.Toggle("Recalc Bounds", mod.recalcbounds);
        mod.recalcCollider = EditorGUILayout.Toggle("Recalc Collider", mod.recalcCollider);
        mod.recalcTangents = EditorGUILayout.Toggle("Recalc Tangents", mod.recalcTangents);
        mod.DoLateUpdate   = EditorGUILayout.Toggle("Do Late Update", mod.DoLateUpdate);
        //mod.GrabVerts = EditorGUILayout.Toggle("Grab Verts", mod.GrabVerts);
        mod.DrawGizmos = EditorGUILayout.Toggle("Draw Gizmos", mod.DrawGizmos);

        if (mod.NormalMethod != method && mod.NormalMethod == MegaNormalMethod.Mega)
        {
            mod.BuildNormalMapping(mod.mesh, false);
        }

        if (GUILayout.Button("Threading Options"))
        {
            showmulti = !showmulti;
        }

        if (showmulti)
        {
            MegaModifiers.ThreadingOn = EditorGUILayout.Toggle("Threading Enabled", MegaModifiers.ThreadingOn);
            mod.UseThreading          = EditorGUILayout.Toggle("Thread This Object", mod.UseThreading);
        }

#if !UNITY_5
        EditorGUIUtility.LookLikeControls();
#endif

        if (GUI.changed)
        {
            EditorUtility.SetDirty(target);
        }

        showorder = EditorGUILayout.Foldout(showorder, "Modifier Order");

        if (showorder && mod.mods != null)
        {
            for (int i = 0; i < mod.mods.Length; i++)
            {
                EditorGUILayout.LabelField("", i.ToString() + " - " + mod.mods[i].ModName() + " " + mod.mods[i].Order);
            }
        }

        if (GUILayout.Button("Targets"))
        {
            showtargets = !showtargets;
        }

        if (showtargets)
        {
            if (GUILayout.Button("Add Target"))
            {
                MegaModifierTarget targ = new MegaModifierTarget();
                mod.targets.Add(targ);
            }

            for (int i = 0; i < mod.targets.Count; i++)
            {
                EditorGUILayout.BeginHorizontal();
                mod.targets[i].go = (GameObject)EditorGUILayout.ObjectField("Target " + i, mod.targets[i].go, typeof(GameObject), true);
                if (GUILayout.Button("Del"))
                {
                    mod.targets.Remove(mod.targets[i]);
                    i--;
                }
                EditorGUILayout.EndHorizontal();
            }
        }
    }
 public Vector3[] GetDestVerts(MegaModifierTarget target)
 {
     return(target.sverts);
 }
    public override void OnInspectorGUI()
    {
        MegaModifyGroup mod = (MegaModifyGroup)target;

        EditorGUIUtility.LookLikeInspector();
        MegaModifiers.GlobalDisplay = EditorGUILayout.Toggle("GlobalDisplayGizmos", MegaModifiers.GlobalDisplay);
        mod.Enabled = EditorGUILayout.Toggle("Enabled", mod.Enabled);
        mod.recalcnorms = EditorGUILayout.Toggle("Recalc Normals", mod.recalcnorms);
        MegaNormalMethod method = mod.NormalMethod;
        mod.NormalMethod = (MegaNormalMethod)EditorGUILayout.EnumPopup("Normal Method", mod.NormalMethod);
        mod.recalcbounds = EditorGUILayout.Toggle("Recalc Bounds", mod.recalcbounds);
        mod.recalcCollider = EditorGUILayout.Toggle("Recalc Collider", mod.recalcCollider);
        mod.recalcTangents = EditorGUILayout.Toggle("Recalc Tangents", mod.recalcTangents);
        mod.DoLateUpdate = EditorGUILayout.Toggle("Do Late Update", mod.DoLateUpdate);
        mod.GrabVerts = EditorGUILayout.Toggle("Grab Verts", mod.GrabVerts);
        mod.DrawGizmos = EditorGUILayout.Toggle("Draw Gizmos", mod.DrawGizmos);

        if ( mod.NormalMethod != method && mod.NormalMethod == MegaNormalMethod.Mega )
        {
            mod.BuildNormalMapping(mod.mesh, false);
        }

        if ( GUILayout.Button("Threading Options") )
            showmulti = !showmulti;

        if ( showmulti )
        {
            MegaModifiers.ThreadingOn = EditorGUILayout.Toggle("Threading Enabled", MegaModifiers.ThreadingOn);
            mod.UseThreading = EditorGUILayout.Toggle("Thread This Object", mod.UseThreading);
        }

        EditorGUIUtility.LookLikeControls();

        if ( GUI.changed )
            EditorUtility.SetDirty(target);

        showorder = EditorGUILayout.Foldout(showorder, "Modifier Order");

        if ( showorder && mod.mods != null )
        {
            for ( int i = 0; i < mod.mods.Length; i++ )
            {
                EditorGUILayout.LabelField("", i.ToString() + " - " + mod.mods[i].ModName() + " " + mod.mods[i].Order);
            }
        }

        if ( GUILayout.Button("Targets") )
            showtargets = !showtargets;

        if ( showtargets )
        {
            if ( GUILayout.Button("Add Target") )
            {
                MegaModifierTarget targ = new MegaModifierTarget();
                mod.targets.Add(targ);
            }

            for ( int i = 0; i < mod.targets.Count; i++ )
            {
                EditorGUILayout.BeginHorizontal();
                mod.targets[i].go = (GameObject)EditorGUILayout.ObjectField("Target " + i, mod.targets[i].go, typeof(GameObject), true);
                if ( GUILayout.Button("Del") )
                {
                    mod.targets.Remove(mod.targets[i]);
                    i--;
                }
                EditorGUILayout.EndHorizontal();
            }
        }
    }
    // Plop into modifiertarget class
    void BuildTangents(MegaModifierTarget target)
    {
        if (uvs == null)
        {
            return;
        }

        int triangleCount = target.mesh.triangles.Length;
        int vertexCount   = target.mesh.vertices.Length;

        if (target.tan1 == null || target.tan1.Length != vertexCount)
        {
            target.tan1 = new Vector3[vertexCount];
        }

        if (target.tan2 == null || target.tan2.Length != vertexCount)
        {
            target.tan2 = new Vector3[vertexCount];
        }

        if (target.tangents == null || target.tangents.Length != vertexCount)
        {
            target.tangents = new Vector4[vertexCount];
        }

        Vector3[] norms = target.mesh.normals;
        int[]     tris  = target.mesh.triangles;

        for (int a = 0; a < triangleCount; a += 3)
        {
            long i1 = tris[a];
            long i2 = tris[a + 1];
            long i3 = tris[a + 2];

            Vector3 v1 = verts[i1];
            Vector3 v2 = verts[i2];
            Vector3 v3 = verts[i3];

            Vector2 w1 = uvs[i1];
            Vector2 w2 = uvs[i2];
            Vector2 w3 = uvs[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);

            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);

            target.tan1[i1] += sdir;
            target.tan1[i2] += sdir;
            target.tan1[i3] += sdir;

            target.tan2[i1] += tdir;
            target.tan2[i2] += tdir;
            target.tan2[i3] += tdir;
        }

        for (int a = 0; a < vertexCount; a++)
        {
            Vector3 n = norms[a];
            Vector3 t = target.tan1[a];

            Vector3.OrthoNormalize(ref n, ref t);
            target.tangents[a].x = t.x;
            target.tangents[a].y = t.y;
            target.tangents[a].z = t.z;
            target.tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), target.tan2[a]) < 0.0f) ? -1.0f : 1.0f;
        }

        target.mesh.tangents = target.tangents;
    }
	public Vector3[] GetDestVerts(MegaModifierTarget target)
	{
		return target.sverts;
	}
 void SetTarget(MegaModifierTarget target)
 {
     InitVertSource();
 }
	public Vector3[] GetSourceVerts(MegaModifierTarget target)
	{
		if ( VertsSource )
		{
			VertsSource = false;
			return target.verts;
		}

		return target.sverts;
		//return UpdateMesh < 1 ? verts : sverts;
	}
    // Need to put bbox into modcontext not use modifier one
    void Start()
    {
        Transform[] objs = (Transform[])gameObject.GetComponentsInChildren<Transform>(true);

        targets = new List<MegaModifierTarget>(objs.Length);

        for ( int i = 0; i < objs.Length; i++ )
        {
            MegaModifierTarget target = new MegaModifierTarget();
            target.go = objs[i].gameObject;

            Mesh ms = GetMesh(target.go);

            if ( ms != null )
            {
                target.cachedMesh = (Mesh)Mesh.Instantiate(ms);
            }

            targets.Add(target);
        }

        GroupReStart1(false);
    }
 void SetTarget(MegaModifierTarget target)
 {
     InitVertSource();
 }
    // Plop into modifiertarget class
    void BuildTangents(MegaModifierTarget target)
    {
        if ( uvs == null )
            return;

        int triangleCount = target.mesh.triangles.Length;
        int vertexCount = target.mesh.vertices.Length;

        if ( target.tan1 == null || target.tan1.Length != vertexCount )
            target.tan1 = new Vector3[vertexCount];

        if ( target.tan2 == null || target.tan2.Length != vertexCount )
            target.tan2 = new Vector3[vertexCount];

        if ( target.tangents == null || target.tangents.Length != vertexCount )
            target.tangents = new Vector4[vertexCount];

        Vector3[] norms	= target.mesh.normals;
        int[]			tris	= target.mesh.triangles;

        for ( int a = 0; a < triangleCount; a += 3 )
        {
            long i1 = tris[a];
            long i2 = tris[a + 1];
            long i3 = tris[a + 2];

            Vector3 v1 = verts[i1];
            Vector3 v2 = verts[i2];
            Vector3 v3 = verts[i3];

            Vector2 w1 = uvs[i1];
            Vector2 w2 = uvs[i2];
            Vector2 w3 = uvs[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);

            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);

            target.tan1[i1] += sdir;
            target.tan1[i2] += sdir;
            target.tan1[i3] += sdir;

            target.tan2[i1] += tdir;
            target.tan2[i2] += tdir;
            target.tan2[i3] += tdir;
        }

        for ( int a = 0; a < vertexCount; a++ )
        {
            Vector3 n = norms[a];
            Vector3 t = target.tan1[a];

            Vector3.OrthoNormalize(ref n, ref t);
            target.tangents[a].x = t.x;
            target.tangents[a].y = t.y;
            target.tangents[a].z = t.z;
            target.tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), target.tan2[a]) < 0.0f) ? -1.0f : 1.0f;
        }

        target.mesh.tangents = target.tangents;
    }
    public void SetMesh(MegaModifierTarget target, ref Vector3[] _verts)
    {
        if ( (dirtyChannels & MegaModChannel.Verts) != 0 )
            target.mesh.vertices = _verts;	// mesh.vertices = GetVerts(true);

        if ( (dirtyChannels & MegaModChannel.UV) != 0 )
            target.mesh.uv = suvs;	//GetUVs(true);

        if ( recalcnorms )
            target.mesh.RecalculateNormals();

        if ( recalcTangents )
            BuildTangents(target);

        if ( recalcbounds )
            target.mesh.RecalculateBounds();

        if ( recalcCollider )
        {
            if ( target.meshCol == null )
                target.meshCol = GetComponent<MeshCollider>();

            if ( target.meshCol != null )
            {
                target.meshCol.sharedMesh = null;
                target.meshCol.sharedMesh = target.mesh;
                //bool con = meshCol.convex;
                //meshCol.convex = con;
            }
        }
    }