public void LateUpdate()
        {
            if (!realtime | (realtime & Application.isPlaying)) {
                //v1.2
                if (!Application.isPlaying) {

                    Multithreaded = false;

                } else {

                    Multithreaded = true;

                }

                //v1.1 -  follow object
                if (FollowObject && PaintedOn != null) {
                    if (!ObjectPosInit) {
                        Registered_initial_position = PaintedOn.position;
                        Registered_initial_rotation = PaintedOn.rotation;
                        Registered_initial_scale = PaintedOn.localScale;
                        ObjectPosInit = true;

                        Updated_Registered_paint_positions.Add (transform.position);
                        Registered_paint_positions.Add (transform.position);
                        Registered_paint_rotations.Add (thisTransf.up);

                        Prev_position = PaintedOn.position;
                        Prev_rotation = PaintedOn.rotation;
                        Prev_scale = PaintedOn.localScale;

                        if (Added_items_handles.Count > 0 && Added_items_handles [0] != null) {//v1.1a
                            GrassManager = Added_items_handles [0].GrassManager;
                        }
                    }

                    //for(int i=0;i<Added_items.Count;i++){		//DO IT WHOLE

                    if (Vector3.Distance (Prev_position, PaintedOn.position) > MinTranslation
                        | Quaternion.Angle (Prev_rotation, PaintedOn.rotation) > MinRotation
                        | Prev_scale != PaintedOn.localScale) {

                        Vector3 FIND_moved_toZERO = Registered_paint_positions [0] - Registered_initial_position;

                        Vector3 FIXED_ROT = PaintedOn.eulerAngles;

                        Quaternion relative = Quaternion.Euler (FIXED_ROT) * Quaternion.Inverse (Registered_initial_rotation);
                        Vector3 FIND_rotated = relative * (FIND_moved_toZERO);  //+ Emitter_objects[counter_regsitered].gameObject.transform.eulerAngles ;

                        Vector3 FIND_scaled = new Vector3 (FIND_rotated.x * (PaintedOn.localScale.x / Registered_initial_scale.x),
                                                      FIND_rotated.y * (PaintedOn.localScale.y / Registered_initial_scale.y),
                                                      FIND_rotated.z * (PaintedOn.localScale.z / Registered_initial_scale.z));

                        Vector3 FIND_re_translated = FIND_scaled + PaintedOn.position;
                        Vector3 FIND_moved_pos = FIND_re_translated;

                        Vector3 FIND_moved_normal_toZERO = Registered_paint_rotations [0];

                        //Vector3 FIND_rotated_normal = relative*(FIND_moved_normal_toZERO);

                        thisTransf.position = FIND_moved_pos;

                        if (!look_at_direction) {
                            thisTransf.rotation = relative * Quaternion.FromToRotation (Vector3.up, FIND_moved_normal_toZERO);
                        } else {

                            //v1.4
                            //if(!look_at_normal){
                            Vector3 Motion_vec = FIND_moved_pos - Updated_Registered_paint_positions [0];

                            Quaternion New_rot = Quaternion.identity;
                            if (Motion_vec != Vector3.zero) {
                                New_rot = Quaternion.LookRotation (1 * Motion_vec);
                                thisTransf.rotation = Quaternion.Slerp (thisTransf.rotation, New_rot, Time.deltaTime * 16);
                            }
                        }

                        //v1.3
                        if(!Application.isPlaying){
                            for(int i=0;i<Added_items_handles.Count;i++){
                                if(Updated_Registered_paint_positions [0] != FIND_moved_pos){
                                    //Added_items_handles[i].transform.position = Added_items_handles[i].transform.position - (Updated_Registered_paint_positions [0]-FIND_moved_pos);
                                    if(Added_items_handles[i].PaintedOnOBJ != null){
                                        Added_items_handles[i].transform.parent = Added_items_handles[i].PaintedOnOBJ;
                                    }
                                }
                                //Added_items_handles[i].transform.rotation = thisTransf.rotation;
                            }
                        }

                        Updated_Registered_paint_positions [0] = FIND_moved_pos;

                        Prev_position = PaintedOn.position;
                        Prev_rotation = PaintedOn.rotation;
                        Prev_scale = PaintedOn.localScale;

                        //Debug.Log("done");
                    }
                    //}

                }

                //Infinigrass
                if (Tag_based_player) {
                    if (player == null) {
                        player = GameObject.FindGameObjectWithTag (Player_tag);
                    }
                } else {
                    if (player == null) {
                        if (Application.isPlaying) {
                            if(Camera.main != null){//v1.4
                                player = Camera.main.gameObject;
                            }else{
                                //Debug.Log("Please add a Main Camera to the scene or use the tag based player option");
                            }
                        } else {
                            //v1.2
                            if (Camera.current != null) {
                                player = Camera.current.gameObject;
                            } else {
                                if(Camera.main != null){//v1.4
                                    player = Camera.main.gameObject;
                                }
                            }
                        }
                    }
                    if (player == null) {
                        if (Camera.current != null) {
                            player = Camera.current.gameObject;
                        }
                    }
            //					if (Application.isPlaying) { //v1.4
            //						if(Camera.main != null){
            //							player = Camera.main.gameObject;
            //						}
            //					}
                }

                if(!Application.isPlaying){
                    if (Camera.current != null) {
                        player = Camera.current.gameObject;
                    }
                }

                //v1.4c
                if(player == null){
                    //Debug.Log("no player assigned");
                    return;
                }

                Hero_far = true;

                if (Application.isPlaying && Added_items != null) {//v1.4
                    for (int i=0; i<Added_items.Count; i++) {
                        if (Added_items [i] != null) {
                            if (Vector3.Distance (Added_items [i].position, player.transform.position) < Deactivate_hero_dist) {
                                Hero_far = false;
                            }
                        }
                    }
                }

                if (Hero_far) {
                    //Debug.Log ("Hero Far");
                }

                //LODed = false;  //v1.4f

                //v1.1 - Fix case where handles are not available
                bool checked_handled = false;

                if (Added_items_handles.Count > 0) {
                    if (Added_items_handles [Added_items_handles.Count - 1].Grow_tree_ended) {
                        checked_handled = true;
                    }
                }

                //v1.3
                LOD_Level = 0;

                if (DeactivateLOD
                    & Hero_far
                    & !is_moving
                    & !Decombined
                    & Added_items.Count > 0
                    & Destroy_list.Count > 0 //){
                    & !MakeActive
                    & Added_items.Count == Added_item_count
                    & checked_handled

                    & Application.isPlaying //v1.2
               //& Added_items_handles[Added_items_handles.Count-1].Grow_tree_ended
               ) {

                    bool Hero_far2 = true;
                    for (int i=0; i<Added_items.Count; i++) {
                        if (Vector3.Distance (Added_items [i].position, player.transform.position) < (Deactivate_hero_dist + Deactivate_hero_offset)) {
                            Hero_far2 = false;
                        }
                    }

                    if (Hero_far2) {
                        //Debug.Log ("Hero Far2");
                    }

                    if (!Hero_far2) {

                        LODed = false;
                        //LOD
                        //re-enable meshes in the threhold region, before system gets fully activated
                        if (Destroy_list_MF.Count > 0) {
                            for (int i=0; i<Destroy_list_MF.Count; i++) {

                                if (Destroy_list_MF [i] != null) {
                                    if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF [i].gameObject.SetActive (false);
                                    } else {
                                        Destroy_list_MF [i].gameObject.SetActive (true);
                                    }
                                }
                            }
                        }
                        if (Destroy_list_MF64.Count > 0) {
                            for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                if (Destroy_list_MF64 [i] != null) {
                                    if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF64 [i].gameObject.SetActive (false);
                                    } else {
                                        Destroy_list_MF64 [i].gameObject.SetActive (true);
                                    }
                                }
                            }
                        }
                    } else {
                        //deactivate and activate LODs

                        //v1.5
                        bool Hero_farCUT = true;

                        bool Hero_farLOD1 = true;
                        bool Hero_farLOD2 = true;

                        if (Added_items != null) {
                            for (int i=0; i<Added_items.Count; i++) {
                                if (Added_items [i] != null) {

                                    //v1.3
                                    float distA = Vector3.Distance (Added_items [i].position, player.transform.position);
                                    if (distA > Deactivate_hero_distCUT*1.5f) {
                                        LOD_Level = 5;
                                    }
                                    if (distA < Deactivate_hero_distCUT) {
                                        Hero_farCUT = false;
                                    }
                                    if (distA < Deactivate_hero_dist1) {
                                        Hero_farLOD1 = false;
                                    }
                                    if (distA < Deactivate_hero_dist2) {
                                        Hero_farLOD2 = false;
                                    }
                                }
                            }
                        }

                        if (Hero_farCUT) {
                            if (Destroy_list_MF.Count > 0) {
                                for (int i=0; i<Destroy_list_MF.Count; i++) {

                                    if (Destroy_list_MF [i] != null) {
                                        if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                            Destroy_list_MF [i].gameObject.SetActive (false);
                                        } else {
                                            Destroy_list_MF [i].gameObject.SetActive (false);
                                        }
                                    }
                                }
                            }
                            if (Destroy_list_MF64.Count > 0) {
                                for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                    if (Destroy_list_MF64 [i] != null) {
                                        if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                            Destroy_list_MF64 [i].gameObject.SetActive (false);
                                        } else {
                                            Destroy_list_MF64 [i].gameObject.SetActive (false);
                                        }
                                    }
                                }
                            }

                            //v1.3
                            if(LOD_Level != 5){
                                LOD_Level = 4;
                            }

                        } else {

                            //INFINIGRASS - added more lods
                            if (Hero_farLOD2) {
                                if (Destroy_list_MF.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF.Count; i++) {

                                        if (Destroy_list_MF [i] != null) {
                                            if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD2")) {
                                                Destroy_list_MF [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }
                                if (Destroy_list_MF64.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                        if (Destroy_list_MF64 [i] != null) {
                                            if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD2")) {
                                                Destroy_list_MF64 [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF64 [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }

                                //v1.3
                                LOD_Level = 3;

                            } else if (Hero_farLOD1) {
                                if (Destroy_list_MF.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF.Count; i++) {

                                        if (Destroy_list_MF [i] != null) {
                                            if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD1")) {
                                                Destroy_list_MF [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }
                                if (Destroy_list_MF64.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                        if (Destroy_list_MF64 [i] != null) {
                                            if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD1")) {
                                                Destroy_list_MF64 [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF64 [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }

                                //v1.3
                                LOD_Level = 2;

                            } else {
                                if (Destroy_list_MF.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF.Count; i++) {

                                        if (Destroy_list_MF [i] != null) {
                                            if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD0")) {
                                                Destroy_list_MF [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }
                                if (Destroy_list_MF64.Count > 0) {
                                    for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                        if (Destroy_list_MF64 [i] != null) {
                                            if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD0")) {
                                                Destroy_list_MF64 [i].gameObject.SetActive (true);
                                            } else {
                                                Destroy_list_MF64 [i].gameObject.SetActive (false);
                                            }
                                        }
                                    }
                                }

                                //v1.3
                                LOD_Level = 1;
                            }

            //						if(Destroy_list_MF.Count>0){
            //							for(int i=0;i<Destroy_list_MF.Count;i++){
            //
            //								if(Destroy_list_MF[i]!=null){
            //									if(Destroy_list_MF[i].gameObject.GetComponent<Renderer>().sharedMaterial.name.Contains("LOD")){
            //										Destroy_list_MF[i].gameObject.SetActive(true);
            //									}else{
            //										Destroy_list_MF[i].gameObject.SetActive(false);
            //									}
            //								}
            //							}
            //						}
            //						if(Destroy_list_MF64.Count>0){
            //							for(int i=0;i<Destroy_list_MF64.Count;i++){
            //
            //								if(Destroy_list_MF64[i]!=null){
            //									if(Destroy_list_MF64[i].gameObject.GetComponent<Renderer>().sharedMaterial.name.Contains("LOD")){
            //										Destroy_list_MF64[i].gameObject.SetActive(true);
            //									}else{
            //										Destroy_list_MF64[i].gameObject.SetActive(false);
            //									}
            //								}
            //							}
            //						}
                        }
                        LODed = true;
                    }
                    //reacivate just before threshold is passed
                } else {

                    if(LODed){
                        //Debug.Log("en");
                        if (Destroy_list_MF.Count > 0) {
                            for (int i=0; i<Destroy_list_MF.Count; i++) {

                                if (Destroy_list_MF [i] != null) {
                                    if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF [i].gameObject.SetActive (false);
                                    } else {
                                        Destroy_list_MF [i].gameObject.SetActive (true);
                                    }
                                }
                            }
                        }
                        if (Destroy_list_MF64.Count > 0) {
                            for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                if (Destroy_list_MF64 [i] != null) {
                                    if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF64 [i].gameObject.SetActive (false);
                                    } else {
                                        Destroy_list_MF64 [i].gameObject.SetActive (true);
                                    }
                                }
                            }
                        }
                    }

                    LODed = false;

                    is_active = false;//start with false, if active signal it

                    if (Self_dynamic_enable) {

                        if (stop_self_dyn_after > 0) {
                            if (Time.fixedTime - self_dyn_enable_time > stop_self_dyn_after) {
                                self_dyn_enable_time = Time.fixedTime;
                                Self_dynamic_enable = false;
                            }
                        }

                        if (Children_list != null) {
                            //v1.7 check if items in list are null and remove from both lists.
                            for (int i=Children_list.Count-1; i>=0; i--) {
                                if (Children_list [i] != null) {
                                    if (Children_list [i].gameObject == null) {
                                        Children_list.RemoveAt (i);
                                        Positions_list.RemoveAt (i);
                                    }
                                }
                            }
                            //if item changed position
                            for (int i=Children_list.Count-1; i>=0; i--) {
                                if (Children_list [i] != null) {

                                    if (Vector3.Distance (Children_list [i].position, Positions_list [i]) > Min_dist) {
                                        MakeActive = true;
                                        Positions_list [i] = Children_list [i].position; //save new pos
                                        //Debug.Log ("ID ="+i);
                                        //Restore();
                                        //v1.6
                                        Multithreaded = false;
                                        Self_dynamic_enable = true;
                                    }
                                    if (Self_dynamic_check_rot) {
                                        if (Rotations_list [i] != Children_list [i].rotation) {
                                            MakeActive = true;
                                            Rotations_list [i] = Children_list [i].rotation; //save new rot
                                        }
                                    }
                                    if (Self_dynamic_check_scale) {
                                        if (Scale_list [i] != Children_list [i].localScale) {
                                            MakeActive = true;
                                            Scale_list [i] = Children_list [i].localScale; //save new scale
                                        }
                                    }
                                }
                            }

                            //if item has been added
                            int child_count = transform.childCount; //v1.8.1 Check PREVIOUS COUNT and not children count

                            if (child_count != previous_children_count) {
                                previous_children_count = child_count;
                                MakeActive = true;
                            }

                        } else {
                            Children_list = new List<Transform> ();
                            Positions_list = new List<Vector3> ();
                            Rotations_list = new List<Quaternion> ();
                            Scale_list = new List<Vector3> ();

                            //v1.6
                            if (!run_once & Self_dynamic_enable) {
                                Component[] filters = GetComponentsInChildren (typeof(MeshFilter));
                                //v1.7
                                if (Self_dynamic_enable & !run_once) {
                                    if (Children_list != null) {
                                        if (filters.Length != Children_list.Count) {

                                            Children_list.Clear ();
                                            Positions_list.Clear ();

                                            if (Self_dynamic_check_rot) {
                                                Rotations_list.Clear ();
                                            }
                                            if (Self_dynamic_check_scale) {
                                                Scale_list.Clear ();
                                            }
                                        }
                                    }
                                }

                                for (int i=0; i<filters.Length; i++) {
                                    Renderer curRenderer = filters [i].GetComponent<Renderer> ();

                                    //v1.7
                                    if (Self_dynamic_enable & !run_once) {
                                        if (Children_list != null) {
                                            if (filters.Length != Children_list.Count) {
                                                Children_list.Add (filters [i].gameObject.transform);
                                                Positions_list.Add (filters [i].gameObject.transform.position);
                                                Rotations_list.Add (filters [i].gameObject.transform.rotation);
                                                Scale_list.Add (filters [i].gameObject.transform.localScale);
                                            }
                                        }
                                    }

                                    if (curRenderer != null && !curRenderer.enabled) {
                                        if (curRenderer.sharedMaterial.name.Contains ("LOD")) {//LOD

                                            curRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;//.castShadows = false;
                                            curRenderer.receiveShadows = false;
                                        } else {
                                            curRenderer.enabled = true;
                                        }
                                    }
                                }
                                run_once = true;
                            }

                            Debug.Log ("LISTS INITIALIZED");
                        }
                    }

                    if (Erase_tree) {
                        Erase_tree = false;
                        Restore ();//de combine all
                        for (int i=Erase_Tree_IDs.Count-1; i>=0; i--) {
                            if (Erase_Tree_IDs [i] <= Added_items.Count) {
                                DestroyImmediate (Added_items [Erase_Tree_IDs [i] - 1].gameObject);
                                Added_items.RemoveAt (Erase_Tree_IDs [i] - 1);
                                DestroyImmediate (Added_items_handles [Erase_Tree_IDs [i] - 1].transform.gameObject);
                                Added_items_handles.RemoveAt (Erase_Tree_IDs [i] - 1);
                            }
                        }
                    }

                    if (Decombine) {

                        //Debug.Log ("INNER DECOMB");

                        Decombine = false; //disable immediately
                        Decombined = true;

                        Start (); //reenable meshfilters
                        MakeActive = false;
                        is_active = false;
                        Self_dynamic_enable = false;

                        //clean up
                        MeshFilter filter1 = this.gameObject.GetComponent (typeof(MeshFilter)) as MeshFilter;
                        if (filter1 != null) {
                            Mesh meshD = filter1.sharedMesh;

                            DestroyImmediate (meshD, true);
                            DestroyImmediate (filter1, true);
                        } else {
                            if (Destroy_list.Count > 0) {
                                for (int i=0; i<Destroy_list.Count; i++) {
                                    MeshFilter filter11 = Destroy_list [i].GetComponent (typeof(MeshFilter)) as MeshFilter;
                                    if (filter11 != null) {
                                        Mesh meshD = filter11.sharedMesh;// this.gameObject.GetComponent <MeshFilter>().sharedMesh;

                                        DestroyImmediate (meshD, true);
                                        DestroyImmediate (filter11, true);
                                    }
                                }
                                for (int i=Destroy_list.Count-1; i>=0; i--) {
                                    Destroy_list_MF.RemoveAt (i);
                                    DestroyImmediate (Destroy_list [i]);
                                    Destroy_list.RemoveAt (i);
                                }
                            }
                            if (Destroy_list64.Count > 0) {
                                for (int i=0; i<Destroy_list64.Count; i++) {

                                    if (Destroy_list_MF64 [i] != null) {
                                        Mesh meshD = Destroy_list_MF64 [i].sharedMesh;

                                        DestroyImmediate (meshD, true);
                                        DestroyImmediate (Destroy_list_MF64 [i], true);
                                    }
                                }
                                for (int i=Destroy_list64.Count-1; i>=0; i--) {
                                    Destroy_list_MF64.RemoveAt (i);
                                    DestroyImmediate (Destroy_list64 [i]);
                                    Destroy_list64.RemoveAt (i);
                                }
                            }
                        }
                    }

                    if (MakeActive) {

                        //LOD - reenable LOD groups to count in combine
                        if (Destroy_list_MF64.Count > 0) {
                            for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                if (Destroy_list_MF64 [i] != null) {
                                    if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF64 [i].gameObject.SetActive (true);
                                    } else {

                                    }
                                }
                            }
                        }
                        if (Destroy_list_MF.Count > 0) {
                            for (int i=0; i<Destroy_list_MF.Count; i++) {

                                if (Destroy_list_MF [i] != null) {
                                    if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {

                                        Destroy_list_MF [i].gameObject.SetActive (true);
                                    } else {

                                    }
                                }
                            }
                        }

                        is_active = true;//start with false, if active signal it

                        if (Auto_Disable) {
                            if (!Multithreaded) {
                                MakeActive = false;
                            }
                        }

                        if (skip_every_N_frame > 0) {
                            if (count_frames >= skip_every_N_frame) {
                                count_frames = 0;

                                return;
                            } else {
                                count_frames = count_frames + 1;
                            }

                        }

                        //activate children
                        if (1 == 1) {

                            if ((!batching_initialized & Multithreaded) | !Multithreaded) {
                                batching_initialized = true;

                                if (Multithreaded & MTmethod2) { // if 2ond method, works best if vertices > 65K, but is a bit slower
                                    Start (); //1. reactivate all and disabled already combined in 2.
                                }

                                if (!Multithreaded) {
                                    Start ();

                                    MeshFilter filter1 = this.gameObject.GetComponent (typeof(MeshFilter)) as MeshFilter;
                                    if (filter1 != null) {
                                        Mesh meshD = filter1.sharedMesh;

                                        DestroyImmediate (meshD, true);
                                        DestroyImmediate (filter1, true);
                                    } else {

                                        if (Destroy_list.Count > 0) {
                                            for (int i=0; i<Destroy_list.Count; i++) {
                                                MeshFilter filter11 = Destroy_list [i].GetComponent (typeof(MeshFilter)) as MeshFilter;
                                                if (filter11 != null) {
                                                    Mesh meshD = filter11.sharedMesh;

                                                    DestroyImmediate (meshD, true);
                                                    DestroyImmediate (filter11, true);
                                                }
                                            }
                                            for (int i=Destroy_list.Count-1; i>=0; i--) {
                                                Destroy_list_MF.RemoveAt (i);
                                                DestroyImmediate (Destroy_list [i]);
                                                Destroy_list.RemoveAt (i);
                                            }
                                        }
                                    }
                                } else if (MTmethod2) { //We cant destroy them to avoid flicker from dissapearence until threads work is over, BUT must be disabled OR WILL BE ADDED to the mix !!!!

                                    //2. disable previously combined

                                    MeshFilter filter1 = this.gameObject.GetComponent (typeof(MeshFilter)) as MeshFilter;
                                    if (filter1 != null) {
                                        filter1.gameObject.SetActive (false);
                                    } else {
                                        if (Destroy_list.Count > 0) {
                                            for (int i=0; i<Destroy_list.Count; i++) {
                                                MeshFilter filter11 = Destroy_list [i].GetComponent (typeof(MeshFilter)) as MeshFilter;
                                                if (filter11 != null) {
                                                    filter11.gameObject.SetActive (false);
                                                }
                                            }
                                        }
                                    }
                                }

                                Component[] filters = GetComponentsInChildren (typeof(MeshFilter));

                                if (Multithreaded & MTmethod2) { //3. re-enable previously combined to avoid flicker while waiting for threads to end
                                    MeshFilter filter1 = this.gameObject.GetComponent (typeof(MeshFilter)) as MeshFilter;
                                    if (filter1 != null) {
                                        filter1.gameObject.SetActive (true);
                                    } else {
                                        if (Destroy_list.Count > 0) {
                                            for (int i=0; i<Destroy_list.Count; i++) {
                                                MeshFilter filter11 = Destroy_list [i].GetComponent (typeof(MeshFilter)) as MeshFilter;
                                                if (filter11 != null) {
                                                    filter11.gameObject.SetActive (true);
                                                }
                                            }
                                        }
                                    }
                                }

                                if (filters != null | 1 == 0) {
                                    if (filters.Length > 0 | 1 == 0) {

                                        Matrix4x4 myTransform = transform.worldToLocalMatrix;
                                        Hashtable materialToMesh = new Hashtable ();
                                        //Debug.Log ("Filters count = "+filters.Length);

                                        int Group_start = 0;
                                        int Group_end = filters.Length;

                                        for (int i=Group_start; i<Group_end; i++) {

                                            MeshFilter filter = (MeshFilter)filters [i];

                                            //	filter.sharedMesh = new Mesh();

                                            if (filter.sharedMesh == null) {
                                                Debug.Log (filter.name);
                                                //return;
                                            }

                                            if (!Multithreaded | (Multithreaded & (
                                                                              (filter.sharedMesh != null && filter.sharedMesh.vertexCount <= 32000 &&
                                                filter.gameObject.name != "Combined mesh64") | MTmethod2))) {

                                                //Debug.Log (filter.gameObject.name);

                                                Renderer curRenderer = filters [i].GetComponent<Renderer> ();

                                                //LOD - check if material is LOD AND has no shadows, must be combined !!! so enable it
                                                // then disable it AND enable shadows to mark it, when decombine disable renderer AND disable shadows in LODs
                                                bool is_LOD = false;
                                                if (curRenderer.sharedMaterial.name.Contains ("LOD") & curRenderer.shadowCastingMode != UnityEngine.Rendering.ShadowCastingMode.On//.castShadows
                                                    & !curRenderer.receiveShadows) {
                                                    curRenderer.enabled = true;
                                                    is_LOD = true;
                                                }

                                                MeshCombineUtilityINfiniDyGrass.MeshInstance instance = new MeshCombineUtilityINfiniDyGrass.MeshInstance ();
                                                instance.mesh = filter.sharedMesh;
                                                if (curRenderer != null && curRenderer.enabled && instance.mesh != null) {
                                                    instance.transform = myTransform * filter.transform.localToWorldMatrix;

                                                    Material[] materials = curRenderer.sharedMaterials;
                                                    for (int m=0; m<materials.Length; m++) {
                                                        instance.subMeshIndex = System.Math.Min (m, instance.mesh.subMeshCount - 1);

                                                        ArrayList objects = (ArrayList)materialToMesh [materials [m]];
                                                        if (objects != null) {
                                                            objects.Add (instance);
                                                        } else {
                                                            objects = new ArrayList ();
                                                            objects.Add (instance);
                                                            materialToMesh.Add (materials [m], objects);
                                                        }
                                                    }

                                                    if (!Multithreaded | (Multithreaded & MTmethod2)) {
                                                        curRenderer.enabled = false;
                                                    }

                                                    //LOD
                                                    if (is_LOD) {
                                                        curRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;//.castShadows = true;
                                                        curRenderer.receiveShadows = true;
                                                        curRenderer.enabled = false;
                                                    }

                                                }
                                            } else {
                                                //Debug.Log (">64k");
                                            }
                                        }

                                        int List_increase = 0;
                                        //int mesh_counter=0;
                                        int counted_entries = 1;
                                        foreach (DictionaryEntry de  in materialToMesh) {

                                            Material_count++;
                                            Material_list.Add ((Material)de.Key);

                                            ArrayList elements = (ArrayList)de.Value;
                                            MeshCombineUtilityINfiniDyGrass.MeshInstance[] instances = (MeshCombineUtilityINfiniDyGrass.MeshInstance[])elements.ToArray (typeof(MeshCombineUtilityINfiniDyGrass.MeshInstance));

                                            List<int> Split_index = new List<int> ();
                                            Split_index.Add (0);

                                            int vertexes_count = 0;
                                            for (int i=0; i<instances.Length; i++) {

                                                vertexes_count = vertexes_count + instances [i].mesh.vertexCount;// filter.sharedMesh.vertexCount;

                                                if (vertexes_count > 64000) {
                                                    vertexes_count = 0;
                                                    Split_index.Add (i);
                                                    Debug.Log ("Split at =" + i);
                                                }
                                            }
                                            //Debug.Log ("Matrial ID ="+de.Key+" "+de.Value);

                                            Splits.Add (Split_index.Count);
                                            for (int j=0; j<Split_index.Count; j++) {

                                                if (!Multithreaded) {

                                                    if (j < Split_index.Count - 1) {
                                                        Group_start = Split_index [j];
                                                        Group_end = Split_index [j + 1] - 1;
                                                    } else {
                                                        Group_start = Split_index [j];
                                                        Group_end = instances.Length;
                                                    }

                                                    MeshCombineUtilityINfiniDyGrass.MeshInstance[] instances_Split = new MeshCombineUtilityINfiniDyGrass.MeshInstance[Group_end - Group_start];
                                                    for (int k=0; k<(Group_end-Group_start); k++) {
                                                        instances_Split [k] = instances [Group_start + k - 0];
                                                    }

                                                    string name = "Combined mesh";
                                                    if (j < Split_index.Count - 1) {
                                                        name = "Combined mesh64";
                                                    }

                                                    GameObject go = new GameObject (name);
                                                    go.transform.parent = transform;
                                                    go.transform.localScale = Vector3.one;
                                                    go.transform.localRotation = Quaternion.identity;
                                                    go.transform.localPosition = Vector3.zero;
                                                    go.AddComponent (typeof(MeshFilter));
                                                    go.AddComponent<MeshRenderer> ();
                                                    go.GetComponent<Renderer> ().material = (Material)de.Key;
                                                    MeshFilter filter = (MeshFilter)go.GetComponent (typeof(MeshFilter));

                                                    //v1.2
                                                    if (Application.isPlaying) {
                                                        filter.mesh = MeshCombineUtilityINfiniDyGrass.Combine (instances_Split, generateTriangleStrips);
                                                    } else {
                                                        filter.sharedMesh = MeshCombineUtilityINfiniDyGrass.Combine (instances_Split, generateTriangleStrips);
                                                    }

                                                    Destroy_list.Add (go);
                                                    Destroy_list_MF.Add (filter);

                                                } else { //MULTITHREADED

                                                    if (j < Split_index.Count - 1) {
                                                        Group_start = Split_index [j];
                                                        Group_end = Split_index [j + 1] - 1;
                                                    } else {
                                                        Group_start = Split_index [j];
                                                        Group_end = instances.Length;
                                                    }

                                                    MeshCombineUtilityINfiniDyGrass.MeshInstance[] instances_Split = new MeshCombineUtilityINfiniDyGrass.MeshInstance[Group_end - Group_start];
                                                    for (int k=0; k<(Group_end-Group_start); k++) {
                                                        instances_Split [k] = instances [Group_start + k - 0];
                                                    }

                                                    if (!all_threads_started) {

                                                        int vertexCount = 0;
                                                        int triangleCount = 0;
                                                        List<int> Combine_Mesh_vertexCount = new List<int> ();
                                                        List<Vector3[]> Combine_Mesh_vertices = new List<Vector3[]> ();
                                                        List<Vector3[]> Combine_Mesh_normals = new List<Vector3[]> ();
                                                        List<Vector4[]> Combine_Mesh_tangets = new List<Vector4[]> ();

                                                        List<Vector2[]> Combine_Mesh_uv = new List<Vector2[]> ();
                                                        List<Vector2[]> Combine_Mesh_uv1 = new List<Vector2[]> ();
                                                        List<Color[]> Combine_Mesh_colors = new List<Color[]> ();
                                                        List<int[]> Combine_Mesh_triangles = new List<int[]> ();
                                                        List<int> Has_mesh = new List<int> ();

                                                        int count = 0;
                                                        foreach (MeshCombineUtilityINfiniDyGrass.MeshInstance combine in instances_Split) {
                                                            if (combine.mesh) {
                                                                vertexCount += combine.mesh.vertexCount;
                                                            }
                                                            //Combine_Mesh_vertexCount[count] = combine.mesh.vertexCount;
                                                            Combine_Mesh_vertexCount.Add (combine.mesh.vertexCount);
                                                            Combine_Mesh_vertices.Add (combine.mesh.vertices);
                                                            Combine_Mesh_normals.Add (combine.mesh.normals);
                                                            Combine_Mesh_tangets.Add (combine.mesh.tangents);

                                                            Combine_Mesh_uv.Add (combine.mesh.uv);
                                                            Combine_Mesh_uv1.Add (combine.mesh.uv2);
                                                            Combine_Mesh_colors.Add (combine.mesh.colors);
                                                            Combine_Mesh_triangles.Add (combine.mesh.GetTriangles (combine.subMeshIndex));

                                                            count++;
                                                        }

                                                        foreach (MeshCombineUtilityINfiniDyGrass.MeshInstance combine in instances_Split) {
                                                            if (combine.mesh) {
                                                                triangleCount += combine.mesh.GetTriangles (combine.subMeshIndex).Length;
                                                                Has_mesh.Add (1);
                                                            } else {
                                                                Has_mesh.Add (0);
                                                            }
                                                        }

                                                        ControlCombineChildrenINfiniDyGrass.Meshy mesh = new ControlCombineChildrenINfiniDyGrass.Meshy ();
                                                        mesh.thread_ended = false;
                                                        MeshList.Add (mesh);
                                                        MeshIDList.Add (0); //signal this thread is not done yet

                                                        int counter_mesh = List_increase;
                                                        LoomINfiniDyGRASS.RunAsync (() => {

                                                            MeshList [counter_mesh] = MeshCombineUtilityINfiniDyGrass.CombineM (counter_mesh, Has_mesh, all_threads_started, instances_Split,
                                                                                                                     generateTriangleStrips, vertexCount, triangleCount,
                                                                                                                     Combine_Mesh_vertexCount, Combine_Mesh_vertices, Combine_Mesh_normals,
                                                                                                                     Combine_Mesh_tangets, Combine_Mesh_uv, Combine_Mesh_uv1, Combine_Mesh_colors, Combine_Mesh_triangles);

                                                        });

                                                        List_increase++;

                                                        //thread_started = true;
                                                        threads_started++;

                                                        if (counted_entries == materialToMesh.Count & j == (Split_index.Count - 1)) {

                                                            all_threads_started = true;
                                                            //mesh_counter = 0;
                                                            //break;
                                                        }

                                                    }

                                                }// END MULTITHREADED ELSE

                                                //Destroy_list.Add(go);
                                            }
                                            counted_entries++;
                                        }//END MATRIAL FOR

                                    }
                                }//END check filters array if exists

                            }// END if !batching_initialized

                            int threads_ended_real = 0;
                            for (int i=0; i<MeshIDList.Count; i++) {
                                if (MeshIDList [i] == 0) {

                                }
                                if (MeshList [i].thread_ended) {
                                    threads_ended_real++;
                                }
                            }

                            if (threads_ended_real >= threads_started & Multithreaded & all_threads_started & 1 == 1) {

                                if (Multithreaded & 1 == 1) {
                                    //Start ();

                                    MeshFilter filter1 = this.gameObject.GetComponent (typeof(MeshFilter)) as MeshFilter;
                                    if (filter1 != null) {
                                        Mesh meshD = filter1.sharedMesh;

                                        DestroyImmediate (meshD, true);
                                        DestroyImmediate (filter1, true);

                                    } else {

                                        if (Destroy_list.Count > 0) {
                                            for (int i=0; i<Destroy_list.Count; i++) {
                                                MeshFilter filter11 = Destroy_list [i].GetComponent (typeof(MeshFilter)) as MeshFilter;
                                                if (filter11 != null) {
                                                    Mesh meshD = filter11.sharedMesh;// this.gameObject.GetComponent <MeshFilter>().sharedMesh;

                                                    DestroyImmediate (meshD, true);
                                                    DestroyImmediate (filter11, true);
                                                }
                                            }
                                            for (int i=Destroy_list.Count-1; i>=0; i--) {
                                                Destroy_list_MF.RemoveAt (i);
                                                DestroyImmediate (Destroy_list [i]);
                                                Destroy_list.RemoveAt (i);
                                            }
                                        }
                                    }
                                }

                                //disable filters NOW

                                Component[] filters = GetComponentsInChildren (typeof(MeshFilter));
                                int Group_start = 0;
                                int Group_end = filters.Length;

                                for (int i=Group_start; i<Group_end; i++) {
                                    MeshFilter filter = (MeshFilter)filters [i];
                                    Renderer curRenderer = filters [i].GetComponent<Renderer> ();

                                    if (curRenderer != null && curRenderer.enabled) {

                                        if (filter.gameObject.name == "Combined mesh64" & !MTmethod2) {

                                        } else {
                                            curRenderer.enabled = false;
                                        }

                                    }
                                }

                                int mesh_counter = 0;
                                for (int i = 0; i<Material_list.Count; i++) {

                                    for (int j=0; j<Splits[i]; j++) {

                                        if (MeshList [mesh_counter].vertices != null) {
                                            //Debug.Log ("Vertex count = "+MeshList[mesh_counter].vertices.Length);
                                            //Debug.Log ("Mesh counter ="+mesh_counter+" IDs = "+MeshIDList[mesh_counter]);
                                        }

                                        if (MeshList [mesh_counter].vertices != null & MeshIDList [mesh_counter] != 1) {

                                            MeshIDList [mesh_counter] = 1;

                                            string name = "Combined mesh";
                                            if (MeshList [mesh_counter].vertices.Length > 32000) {
                                                name = "Combined mesh64";
                                            }

                                            GameObject go = new GameObject (name);
                                            go.transform.parent = transform;
                                            go.transform.localScale = Vector3.one;
                                            go.transform.localRotation = Quaternion.identity;
                                            go.transform.localPosition = Vector3.zero;
                                            go.AddComponent (typeof(MeshFilter));
                                            go.AddComponent<MeshRenderer> ();
                                            go.GetComponent<Renderer> ().material = Material_list [i];//(Material)de.Key;
                                            MeshFilter filter = (MeshFilter)go.GetComponent (typeof(MeshFilter));

                                            if (MeshList [mesh_counter].vertices.Length > 0) {

                                                //v1.2
                                                if (Application.isPlaying) {
                                                    filter.mesh.name = MeshList [mesh_counter].name;
                                                    filter.mesh.vertices = MeshList [mesh_counter].vertices;
                                                    filter.mesh.normals = MeshList [mesh_counter].normals;
                                                    filter.mesh.colors = MeshList [mesh_counter].colors;
                                                    filter.mesh.uv = MeshList [mesh_counter].uv;
                                                    filter.mesh.uv2 = MeshList [mesh_counter].uv1;
                                                    filter.mesh.tangents = MeshList [mesh_counter].tangents;
                                                    filter.mesh.triangles = MeshList [mesh_counter].triangles;
                                                } else {
                                                    if (filter.sharedMesh != null) {
                                                        filter.sharedMesh.name =
                                                    MeshList [mesh_counter].name;
                                                        filter.sharedMesh.vertices = MeshList [mesh_counter].vertices;
                                                        filter.sharedMesh.normals = MeshList [mesh_counter].normals;
                                                        filter.sharedMesh.colors = MeshList [mesh_counter].colors;
                                                        filter.sharedMesh.uv = MeshList [mesh_counter].uv;
                                                        filter.sharedMesh.uv2 = MeshList [mesh_counter].uv1;
                                                        filter.sharedMesh.tangents = MeshList [mesh_counter].tangents;
                                                        filter.sharedMesh.triangles = MeshList [mesh_counter].triangles;
                                                    }
                                                }
                                                //thread_started = false;

                                                threads_ended = threads_ended + 1;
                                            }

                                            if (MeshList [mesh_counter].vertices.Length <= 32000) {
                                                Destroy_list.Add (go);
                                                Destroy_list_MF.Add (filter);
                                            } else {
                                                Destroy_list64.Add (go);
                                                Destroy_list_MF64.Add (filter);
                                            }
                                        }
                                        mesh_counter++;
                                    }
                                }

                                Splits.Clear ();
                                Splits = new List<int> ();
                                Material_count = 0;
                                Material_list.Clear ();
                                Material_list = new List<Material> ();

                                batching_initialized = false;

                                threads_ended = 0;
                                threads_started = 0;
                                MeshList.Clear ();
                                MeshList = new List<Meshy> ();

                                MeshIDList.Clear ();
                                MeshIDList = new List<int> ();
                                //MeshList.
                                all_threads_started = false;
                                mesh_counter = 0;
                                if (Auto_Disable) {
                                    MakeActive = false;
                                }

                            }

                        }//end if use bones
                        //END IF BONES

                        //LOD - reenable LOD groups to count in combine
                        if (Destroy_list_MF64.Count > 0) {
                            for (int i=0; i<Destroy_list_MF64.Count; i++) {

                                if (Destroy_list_MF64 [i] != null) {
                                    if (Destroy_list_MF64 [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF64 [i].gameObject.SetActive (false);
                                    } else {

                                    }
                                }
                            }
                        }
                        if (Destroy_list_MF.Count > 0) {
                            for (int i=0; i<Destroy_list_MF.Count; i++) {

                                if (Destroy_list_MF [i] != null) {
                                    if (Destroy_list_MF [i].gameObject.GetComponent<Renderer> ().sharedMaterial.name.Contains ("LOD")) {
                                        Destroy_list_MF [i].gameObject.SetActive (false);
                                    } else {

                                    }
                                }
                            }
                        }

                    }//END MAKEACTIVE

                }//END hero check

                //v1.1
            //			if (PaintedOn != null) {
            //				Prev_position = PaintedOn.position;
            //				Prev_rotation = PaintedOn.rotation;
            //				Prev_scale = PaintedOn.localScale;
            //			}
            }
        }
        void Awake()
        {
            script = (InfiniGRASSManager)target;

            script.GrassPrefab = grass_prefab as GameObject;

            if (script.FencesHolder == null) {
                GameObject FencesHolder = new GameObject();
                FencesHolder.transform.parent = script.transform;
                FencesHolder.name = "Fences Holder";
                script.FencesHolder = FencesHolder;
                FencesHolder.AddComponent<ControlCombineChildrenINfiniDyGrass>().MakeActive = true;
                FencesHolder.GetComponent<ControlCombineChildrenINfiniDyGrass>().Auto_Disable = true;
                FencesHolder.GetComponent<ControlCombineChildrenINfiniDyGrass>().realtime = true;
            }
            if (script.RocksHolder == null) {
                GameObject RocksHolder = new GameObject();
                RocksHolder.transform.parent = script.transform;
                RocksHolder.name = "Rocks Holder";
                script.RocksHolder = RocksHolder;
                RocksHolder.AddComponent<ControlCombineChildrenINfiniDyGrass>().MakeActive = true;
                RocksHolder.GetComponent<ControlCombineChildrenINfiniDyGrass>().Auto_Disable = true;
                RocksHolder.GetComponent<ControlCombineChildrenINfiniDyGrass>().realtime = true;
            }
            if (script.GrassHolder == null) {
                GameObject GrassHolder = new GameObject();
                GrassHolder.transform.parent = script.transform;
                GrassHolder.name = "Grass Holder";
                script.GrassHolder = GrassHolder;
            }
            if (script.GrassBatchHolder == null) {
                GameObject GrassBatchHolder = new GameObject();
                //GrassBatchHolder.transform.parent = script.transform;
                GrassBatchHolder.name = "GrassBatchHolder";
                script.GrassBatchHolder = GrassBatchHolder;
            }
        }
        //InfiniGRASS
        void Update()
        {
            //v1.4 - update tag player status
            //			if (GrassManager != null) {
            //				Tag_based_player = GrassManager.Tag_based_player;
            //			} else {
            //				//Debug.Log("as");
            //			}

            if (!realtime | (realtime & Application.isPlaying)) {
            //v1.2
                //Debug.Log(started);
            if (!started & !Application.isPlaying) {
                Start ();
                started = true;
            }

            if (started & !Application.isPlaying) {
                Component[] filters = GetComponentsInChildren (typeof(MeshFilter));
                for (int i=0; i<filters.Length; i++) {
                    if (filters [i].gameObject.name != "Combined mesh64" & filters [i].gameObject.name != "Combined mesh") {
                        filters [i].gameObject.GetComponent<MeshRenderer> ().enabled = false;
                    }
                }
            }

                //v1.3
                if (GrassManager == null) {
                    if (Added_items_handles.Count > 0 && Added_items_handles [0] != null) {//v1.1a
                        GrassManager = Added_items_handles [0].GrassManager;
                    }
                }

            //v1.1 - clean up when follow object and object is deleted
            if (FollowObject && ObjectPosInit && PaintedOn == null && Added_items.Count > 0) {

                //v1.1
            //				if (GrassManager == null) {
            //					if (Added_items_handles.Count > 0 && Added_items_handles [0] != null) {//v1.1a
            //						GrassManager = Added_items_handles [0].GrassManager;
            //					}
            //				}

                if (GrassManager != null) {

                    //v1.2
                    if(!Application.isPlaying){
                        for(int j=GrassManager.DynamicCombiners.Count-1;j>=0;j--){
                            if(GrassManager.DynamicCombiners[j] != null && GrassManager.DynamicCombiners[j] == this.gameObject){
                                GrassManager.DynamicCombiners.RemoveAt(j);
                            }
                        }
                        for(int j=GrassManager.StaticCombiners.Count-1;j>=0;j--){
                            if(GrassManager.StaticCombiners[j] != null && GrassManager.StaticCombiners[j] == this.gameObject){
                                GrassManager.StaticCombiners.RemoveAt(j);
                            }
                        }

                        for (int j = Added_items_handles.Count-1; j>=0; j--) {
                            if(Added_items_handles[j] != null && Added_items_handles[j].gameObject != null){
                                DestroyImmediate(Added_items_handles[j].gameObject);
                            }
                        }
                    }

                    for (int j = GrassManager.Grasses.Count -1; j>=0; j--) {
                        if (GrassManager.Grasses [j] == null) {
                            GrassManager.Grasses.RemoveAt (j);
                            GrassManager.GrassesType.RemoveAt (j);
                        }
                    }

                    for (int j=0; j<GrassManager.Grasses.Count; j++) {
                        GrassManager.Grasses [j].Grass_Holder_Index = j;
                    }
                }

                //v.1.2
                if(Application.isPlaying){
                    Destroy (this.gameObject);
                }else{
                    DestroyImmediate (this.gameObject);
                }
            }

            //LOD - get from first added and never change
            if (!got_LOD_dist && Added_items_handles.Count > 0 && Added_items_handles [0] != null) {
                if (Deactivate_hero_dist != Added_items_handles [0].LOD_distance) {
                    Deactivate_hero_dist = Added_items_handles [0].LOD_distance;
                }
                if (Deactivate_hero_dist1 != Added_items_handles [0].LOD_distance1) {
                    Deactivate_hero_dist1 = Added_items_handles [0].LOD_distance1;
                }
                if (Deactivate_hero_dist2 != Added_items_handles [0].LOD_distance2) {
                    Deactivate_hero_dist2 = Added_items_handles [0].LOD_distance2;
                }
                if (Deactivate_hero_distCUT != Added_items_handles [0].Cutoff_distance) {
                    Deactivate_hero_distCUT = Added_items_handles [0].Cutoff_distance;
                }
                got_LOD_dist = true;
            }

            if (Added_items.Count == 0 & batching_initialized & Max_items > 0) {
                batching_initialized = false;
                MakeActive = false;
                is_active = false;
                Decombined = false;
                mesh_initalized = false;

                //v1.2
                if (Application.isPlaying) {
                    Destroy (this.gameObject);
                } else {
                    DestroyImmediate (this.gameObject);
                }
                //Debug.Log("init");
            }

            //v1.3 - clean up if away from hero and in gradual grow mode
            if(Application.isPlaying && GrassManager != null && GrassManager.UnGrown){
                    if(GrassManager.GradualGrowth & GrassManager.UseDistFromPlayer & GrassManager.GradualRecreate & LOD_Level == 5){

                        //erase elements
                        for (int j = Added_items_handles.Count -1; j>=0; j--) {
                            INfiniDyGrassField forest = Added_items_handles[j];
                            //EXTRAS
                            GameObject LEAF_POOL = new GameObject ();
                            LEAF_POOL.transform.parent = forest.transform;
                            forest.Leaf_pool = LEAF_POOL;
                            forest.Combiner = null;
                            forest.Grow_in_Editor = false;
                            forest.growth_over = false;
                            forest.Registered_Brances.Clear ();//
                            //forest.root_tree = null;
                            forest.Branch_grew.Clear ();
                            forest.Registered_Leaves.Clear ();//
                            forest.Registered_Leaves_Rot.Clear ();//
                            forest.batching_ended = false;
                            forest.Branch_levels.Clear ();
                            forest.BranchID_per_level.Clear ();
                            //forest.Grass_Holder_Index = 0;
                            forest.Grow_level = 0;
                            forest.Grow_tree_ended = false;
                            forest.Health = forest.Max_Health;
                            forest.is_moving = false;
                            forest.Leaf_belongs_to_branch.Clear ();
                            forest.scaleVectors.Clear ();
                            forest.Leaves.Clear ();
                            forest.Tree_Holder_Index = 0;
                            forest.Grow_tree = false;
                            forest.rotation_over = false;
                            forest.Forest_holder = null;

                            forest.Grow_tree_speed = 1000;
                            forest.Restart = true;

                            //v1.3
                            forest.gameObject.SetActive(false);

                        }

            //						for (int j = Added_items_handles.Count-1; j>=0; j--) {
            //							DestroyImmediate(Added_items_handles[j].gameObject);
            //						}
            //
            //						for (int j = GrassManager.Grasses.Count -1; j>=0; j--) {
            //							if (GrassManager.Grasses [j] == null) {
            //								GrassManager.Grasses.RemoveAt (j);
            //								GrassManager.GrassesType.RemoveAt (j);
            //							}
            //						}
            //
            //						for (int j=0; j<GrassManager.Grasses.Count; j++) {
            //							GrassManager.Grasses [j].Grass_Holder_Index = j;
            //						}

                        Destroy (this.gameObject);
                    }
            }

              }//REAL TIME CHECK
        }