GSDRoadUtility.cs

#region "Imports"
using UnityEngine;
using System.Collections.Generic;
//using System.Collections;                     // Unused
using System.IO;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
#endregion


namespace GSD.Roads
{
    //Generic http://www.fhwa.dot.gov/bridge/bridgerail/br053504.cfm
    public enum RailingTypeEnum { None, Generic1, Generic2, K_Rail, WBeam };
    public enum RailingSubTypeEnum { Both, Left, Right };
    public enum SignPlacementSubTypeEnum { Center, Left, Right };
    public enum CenterDividerTypeEnum { None, K_Rail, KRail_Blinds, Wire, Markers };
    public enum EndCapTypeEnum { None, WBeam, Barrels3Static, Barrels3Rigid, Barrels7Static, Barrels7Rigid };
    public enum RoadUpdateTypeEnum { Full, Intersection, Railing, CenterDivider, Bridges };
    public enum AxisTypeEnum { X, Y, Z };

#if UNITY_EDITOR
    public static class GSDConstruction
    {
        public static GSDSplineN CreateNode(GSDRoad RS, bool bSpecialEndNode = false, Vector3 vSpecialLoc = default(Vector3), bool bInterNode = false)
        {
            Object[] tWorldNodeCount = GameObject.FindObjectsOfType(typeof(GSDSplineN));
            GameObject tNodeObj = new GameObject("Node" + tWorldNodeCount.Length.ToString());
            if (!bInterNode)
            {
                UnityEditor.Undo.RegisterCreatedObjectUndo(tNodeObj, "Created node");
            }
            GSDSplineN tNode = tNodeObj.AddComponent<GSDSplineN>();

            if (bSpecialEndNode)
            {
                tNode.bSpecialEndNode = true;
                tNodeObj.transform.position = vSpecialLoc;
            }
            else
            {
                tNodeObj.transform.position = RS.Editor_MousePos;
                //This helps prevent double clicks:
                int mCount = RS.GSDSpline.GetNodeCount();
                for (int index = 0; index < mCount; index++)
                {
                    if (Vector3.Distance(RS.Editor_MousePos, RS.GSDSpline.mNodes[index].pos) < 5f)
                    {
                        Object.DestroyImmediate(tNodeObj);
                        return null;
                    }
                }
                //End double click prevention
            }
            Vector3 xVect = tNodeObj.transform.position;
            if (xVect.y < 0.03f)
            {
                xVect.y = 0.03f;
            }
            tNodeObj.transform.position = xVect;

            tNodeObj.transform.parent = RS.GSDSplineObj.transform;
            tNode.idOnSpline = RS.GSDSpline.GetNodeCount() + 1;
            tNode.GSDSpline = RS.GSDSpline;

            //Enforce max road grade:
            if (RS.opt_bMaxGradeEnabled && !bSpecialEndNode)
            {
                tNode.EnsureGradeValidity(-1, true);
            }

            if (!bInterNode && !bSpecialEndNode)
            {
                RS.UpdateRoad();
            }
            return tNode;
        }
        //Insert
        //Detect closest node (if end node, auto select other node)
        //Determine which node is closest (up or down) on spline
        //Place node, adjust all id on splines
        //Setup spline
        public static GSDSplineN InsertNode(GSDRoad RS, bool bForcedLoc = false, Vector3 ForcedLoc = default(Vector3), bool bIsPreNode = false, int InsertIndex = -1, bool bSpecialEndNode = false, bool bInterNode = false)
        {
            GameObject tNodeObj;
            Object[] tWorldNodeCount = GameObject.FindObjectsOfType(typeof(GSDSplineN));
            if (!bForcedLoc)
            {
                tNodeObj = new GameObject("Node" + tWorldNodeCount.Length.ToString());
            }
            else if (bForcedLoc && !bSpecialEndNode)
            {
                tNodeObj = new GameObject("Node" + tWorldNodeCount.Length.ToString() + "Ignore");
            }
            else
            {
                tNodeObj = new GameObject("Node" + tWorldNodeCount.Length.ToString());
            }
            if (!bInterNode)
            {
                UnityEditor.Undo.RegisterCreatedObjectUndo(tNodeObj, "Inserted node");
            }

            if (!bForcedLoc)
            {
                tNodeObj.transform.position = RS.Editor_MousePos;

                //This helps prevent double clicks:
                int mCount = RS.GSDSpline.GetNodeCount();
                for (int index = 0; index < mCount; index++)
                {
                    if (Vector3.Distance(RS.Editor_MousePos, RS.GSDSpline.mNodes[index].pos) < 15f)
                    {
                        Object.DestroyImmediate(tNodeObj);
                        return null;
                    }
                }
                //End double click prevention
            }
            else
            {
                tNodeObj.transform.position = ForcedLoc;
            }
            Vector3 xVect = tNodeObj.transform.position;
            if (xVect.y < 0.03f)
            {
                xVect.y = 0.03f;
            }
            tNodeObj.transform.position = xVect;
            tNodeObj.transform.parent = RS.GSDSplineObj.transform;

            int cCount = RS.GSDSpline.mNodes.Count;
            //			float mDistance = 50000f;
            //			float tDistance = 0f;

            float tParam;
            if (!bForcedLoc)
            {
                tParam = RS.GSDSpline.GetClosestParam(RS.Editor_MousePos, false, true);
            }
            else
            {
                tParam = RS.GSDSpline.GetClosestParam(ForcedLoc, false, true);
            }
            bool bEndInsert = false;
            bool bZeroInsert = false;
            int iStart = 0;
            if (GSDRootUtil.IsApproximately(tParam, 0f, 0.0001f))
            {
                bZeroInsert = true;
                iStart = 0;
            }
            else if (GSDRootUtil.IsApproximately(tParam, 1f, 0.0001f))
            {
                bEndInsert = true;
            }

            if (bForcedLoc)
            {
                iStart = InsertIndex;
            }
            else
            {
                for (int index = 0; index < cCount; index++)
                {
                    GSDSplineN xNode = RS.GSDSpline.mNodes[index];
                    if (!bZeroInsert && !bEndInsert)
                    {
                        if (tParam > xNode.tTime)
                        {
                            iStart = xNode.idOnSpline + 1;
                        }
                    }
                }
            }

            if (bEndInsert)
            {
                iStart = RS.GSDSpline.mNodes.Count;
            }
            else
            {
                for (int i = iStart; i < cCount; i++)
                {
                    RS.GSDSpline.mNodes[i].idOnSpline += 1;
                }
            }

            GSDSplineN tNode = tNodeObj.AddComponent<GSDSplineN>();
            if (bForcedLoc && !bSpecialEndNode)
            {
                tNode.bIsBridge = true;
                tNode.bIgnore = true;
                //				tNode.bIsBridge_PreNode = bIsPreNode;
                //				tNode.bIsBridge_PostNode = !bIsPreNode;	
            }
            tNode.GSDSpline = RS.GSDSpline;
            tNode.idOnSpline = iStart;
            tNode.bSpecialEndNode = bSpecialEndNode;
            if (!bForcedLoc)
            {
                tNode.pos = RS.Editor_MousePos;
            }
            else
            {
                tNode.pos = ForcedLoc;
            }

            RS.GSDSpline.mNodes.Insert(iStart, tNode);

            //Enforce maximum road grade:
            if (!bForcedLoc && !bSpecialEndNode && RS.opt_bMaxGradeEnabled)
            {
                tNode.EnsureGradeValidity(iStart);
            }

            if (!bInterNode && !bSpecialEndNode)
            {
                if (!bForcedLoc)
                {
                    RS.UpdateRoad();
                }
            }

            return tNode;
        }
    }


    public static class GSDTerraforming
    {
        public class TempTerrainData
        {
            public int HM;
            public int HMHeight;
            public float[,] heights;
            public bool[,] tHeights;

            public float HMRatio;
            public float MetersPerHM = 0f;

            //Heights:
            public ushort[] cX;
            public ushort[] cY;
            public float[] cH;
            public float[] oldH;
            public int cI = 0;
            public int TerrainMaxIndex;

            //Details:
            public int DetailLayersCount;

            public List<ushort> MainDetailsX;
            public List<ushort> MainDetailsY;

            public List<List<ushort>> DetailsX;
            public List<List<ushort>> DetailsY;
            public List<List<ushort>> OldDetailsValue;
            //			public Dictionary<int,int[,]> DetailValues;
            public int[] DetailsI;
            public float DetailToHeightRatio;


            //			public Dictionary<int,bool[,]> DetailHasProcessed;

            public HashSet<int> DetailHasProcessed;



            //			public List<List<bool>> OldDetailsValue;

            public int DetailMaxIndex;
            public HashSet<int> DetailLayersSkip;

            //Trees
            public List<TreeInstance> TreesCurrent;
            public List<TreeInstance> TreesOld;
            public int TreesI;
            public int TreeSize;

            public Vector3 TerrainSize;
            public Vector3 TerrainPos;
            public int GSDID;


            public void Nullify()
            {
                heights = null;
                tHeights = null;
                cX = null;
                cY = null;
                cH = null;
                oldH = null;
                //				DetailsX = null;
                //				DetailsY = null;
                //				DetailValues = null;
                OldDetailsValue = null;
                //				DetailsI = null;
                TreesCurrent = null;
                TreesOld = null;
            }
        }


        private static void CheckAllTerrains()
        {
            Object[] tTerrains = GameObject.FindObjectsOfType(typeof(Terrain));
            GSDTerrain TID;
            GameObject tObj;
            foreach (Terrain tTerrain in tTerrains)
            {
                tObj = tTerrain.transform.gameObject;
                TID = tObj.GetComponent<GSDTerrain>();
                if (TID == null)
                {
                    TID = tObj.AddComponent<GSDTerrain>();
                }
                TID.CheckID();
            }
        }


        public static void CheckAllTerrainsHeight0()
        {
            CheckAllTerrains();
            Object[] tTerrains = GameObject.FindObjectsOfType(typeof(Terrain));
            foreach (Terrain tTerrain in tTerrains)
            {
                if (!GSDRootUtil.IsApproximately(tTerrain.transform.position.y, 0f, 0.0001f))
                {
                    Vector3 tVect = tTerrain.transform.position;
                    tVect.y = 0f;
                    tTerrain.transform.position = tVect;
                }
            }
        }


        public static void ProcessRoad_Terrain_Hook1(GSDSplineC tSpline, GSDRoad tRoad, bool bMultithreaded = true)
        {
            ProcessRoad_Terrain_Hook1_Do(ref tSpline, ref tRoad, bMultithreaded);
        }


        private static void ProcessRoad_Terrain_Hook1_Do(ref GSDSplineC tSpline, ref GSDRoad tRoad, bool bMultithreaded)
        {
            GSDRootUtil.StartProfiling(tRoad, "ProcessRoad_Terrain_Hook1_Do");
            //First lets make sure all terrains have GSD shit on them:
            CheckAllTerrains();

            //Reset the terrain:
            GSDRootUtil.StartProfiling(tRoad, "TerrainsReset");
            GSDTerraforming.TerrainsReset(tRoad);
            GSDRootUtil.EndProfiling(tRoad);

            float heightDistance = tRoad.opt_MatchHeightsDistance;
            //			float treeDistance = tRoad.opt_ClearTreesDistance;
            float detailDistance = tRoad.opt_ClearDetailsDistance;

            Dictionary<Terrain, TempTerrainData> TempTerrainDict = new Dictionary<Terrain, TempTerrainData>();
            //Populate dictionary:
            Object[] tTerrains = GameObject.FindObjectsOfType(typeof(Terrain));
            GSDTerrain TID;
            int aSize = 0;
            int dSize = 0;
            TempTerrainData TTD;
            bool bContains = false;
            GSDRoadUtil.Construction2DRect tRect = null;
            //			GSDRoadUtil.Construction2DRect rRect = null;
            foreach (Terrain tTerrain in tTerrains)
            {
                if (tTerrain.terrainData == null)
                    continue;
                tRect = GetTerrainBounds(tTerrain);
                bContains = false;
                //Debug.Log(tTerrain.transform.name + " bounds: " + tRect.ToStringGSD());
                //Debug.Log("  Road bounds: " + tSpline.RoadV0 + "," + tSpline.RoadV1 + "," + tSpline.RoadV2 + "," + tSpline.RoadV3);

                if (bContains != true && tRect.Contains(ref tSpline.RoadV0))
                {
                    bContains = true;
                }
                else if (bContains != true && tRect.Contains(ref tSpline.RoadV1))
                {
                    bContains = true;
                }
                else if (bContains != true && tRect.Contains(ref tSpline.RoadV2))
                {
                    bContains = true;
                }
                else if (bContains != true && tRect.Contains(ref tSpline.RoadV3))
                {
                    bContains = true;
                }
                else
                {
                    int mCount3 = tRoad.GSDSpline.GetNodeCount();
                    Vector2 tVect2D_321 = default(Vector2);
                    for (int index = 0; index < mCount3; index++)
                    {
                        tVect2D_321 = new Vector2(tRoad.GSDSpline.mNodes[index].pos.x, tRoad.GSDSpline.mNodes[index].pos.z);
                        if (tRect.Contains(ref tVect2D_321))
                        {
                            bContains = true;
                            break;
                        }
                    }

                    if (!bContains)
                    {
                        float tDef = 5f / tSpline.distance;
                        Vector2 x2D = default(Vector2);
                        Vector3 x3D = default(Vector3);
                        for (float index = 0f; index <= 1f; index += tDef)
                        {
                            x3D = tSpline.GetSplineValue(index);
                            x2D = new Vector2(x3D.x, x3D.z);
                            if (tRect.Contains(ref x2D))
                            {
                                bContains = true;
                                break;
                            }
                        }
                    }
                }

                //				rRect = new GSD.Roads.GSDRoadUtil.Construction2DRect(tSpline.RoadV0,tSpline.RoadV1,tSpline.RoadV2,tSpline.RoadV3);


                if (bContains && !TempTerrainDict.ContainsKey(tTerrain))
                {
                    TTD = new TempTerrainData();
                    TTD.HM = tTerrain.terrainData.heightmapResolution;
                    TTD.HMHeight = tTerrain.terrainData.heightmapHeight;
                    TTD.heights = tTerrain.terrainData.GetHeights(0, 0, tTerrain.terrainData.heightmapWidth, tTerrain.terrainData.heightmapHeight);
                    TTD.HMRatio = TTD.HM / tTerrain.terrainData.size.x;
                    TTD.MetersPerHM = tTerrain.terrainData.size.x / tTerrain.terrainData.heightmapResolution;
                    float DetailRatio = tTerrain.terrainData.detailResolution / tTerrain.terrainData.size.x;

                    //Heights:
                    GSDRootUtil.StartProfiling(tRoad, "Heights");
                    if (tRoad.opt_HeightModEnabled)
                    {
                        aSize = (int) tSpline.distance * ((int) (heightDistance * 1.65f * TTD.HMRatio) + 2);
                        if (aSize > (tTerrain.terrainData.heightmapResolution * tTerrain.terrainData.heightmapResolution))
                        {
                            aSize = tTerrain.terrainData.heightmapResolution * tTerrain.terrainData.heightmapResolution;
                        }
                        TTD.cX = new ushort[aSize];
                        TTD.cY = new ushort[aSize];
                        TTD.oldH = new float[aSize];
                        TTD.cH = new float[aSize];
                        TTD.cI = 0;
                        TTD.TerrainMaxIndex = tTerrain.terrainData.heightmapResolution;
                        TTD.TerrainSize = tTerrain.terrainData.size;
                        TTD.TerrainPos = tTerrain.transform.position;
                        TTD.tHeights = new bool[tTerrain.terrainData.heightmapWidth, tTerrain.terrainData.heightmapHeight];
                        TID = tTerrain.transform.gameObject.GetComponent<GSDTerrain>();
                        if (TID != null)
                        {
                            TTD.GSDID = TID.GSDID;
                            TempTerrainDict.Add(tTerrain, TTD);
                        }
                    }

                    //Details:
                    GSDRootUtil.EndStartProfiling(tRoad, "Details");
                    if (tRoad.opt_DetailModEnabled)
                    {
                        //						TTD.DetailValues = new Dictionary<int, int[,]>();
                        TTD.DetailLayersCount = tTerrain.terrainData.detailPrototypes.Length;
                        //						TTD.DetailHasProcessed = new Dictionary<int, bool[,]>();
                        TTD.DetailHasProcessed = new HashSet<int>();
                        TTD.MainDetailsX = new List<ushort>();
                        TTD.MainDetailsY = new List<ushort>();
                        TTD.DetailsI = new int[TTD.DetailLayersCount];
                        TTD.DetailToHeightRatio = (float) ((float) tTerrain.terrainData.detailResolution) / ((float) tTerrain.terrainData.heightmapResolution);
                        TTD.DetailMaxIndex = tTerrain.terrainData.detailResolution;
                        TTD.DetailLayersSkip = new HashSet<int>();

                        // Get all of layer zero.
                        //						int[] mMinMaxDetailEntryCount = new int[TTD.DetailLayersCount];
                        //						GSDRootUtil.StartProfiling(tRoad, "DetailValues");
                        //						Vector3 bVect = default(Vector3);
                        //						Vector2 bVect2D = default(Vector2);
                        //						int DetailRes = tTerrain.terrainData.detailResolution;
                        //						for(int i=0;i<TTD.DetailLayersCount;i++){
                        //							int[,] tInts = tTerrain.terrainData.GetDetailLayer(0,0,tTerrain.terrainData.detailWidth,tTerrain.terrainData.detailHeight,i);
                        //							int Length1 = tInts.GetLength(0);
                        //							int Length2 = tInts.GetLength(1);
                        //							for (int y=0;y < Length1;y++){
                        //								for (int x=0;x < Length2;x++){
                        //									if(tInts[x,y] > 0){
                        //										bVect = new Vector3(((float)y/(float)DetailRes) * TTD.TerrainSize.x,0f,((float)x/(float)DetailRes) * TTD.TerrainSize.z);
                        //										bVect = tTerrain.transform.TransformPoint(bVect);
                        //										bVect2D = new Vector2(bVect.z,bVect.x);
                        //										if(rRect.Contains(ref bVect2D)){
                        //											mMinMaxDetailEntryCount[i] += 1;
                        //										}
                        //									}
                        //								}
                        //							}

                        //							if(mMinMaxDetailEntryCount[i] < 1){
                        //								TTD.DetailLayersSkip.Add(i);
                        //								tInts = null;
                        //							}else{
                        //								TTD.DetailValues.Add(i,tInts);
                        //								TTD.DetailHasProcessed.Add(i,new bool[tTerrain.terrainData.detailWidth,tTerrain.terrainData.detailHeight]);
                        //							}
                        //						}
                        //						GSDRootUtil.EndProfiling(tRoad);


                        dSize = (int) tSpline.distance * ((int) (detailDistance * 3f * DetailRatio) + 2);
                        if (dSize > (tTerrain.terrainData.detailResolution * tTerrain.terrainData.detailResolution))
                        {
                            dSize = tTerrain.terrainData.detailResolution * tTerrain.terrainData.detailResolution;
                        }

                        //						TTD.DetailsX = new List<ushort[]>();
                        //						TTD.DetailsY = new List<ushort[]>();
                        //						TTD.OldDetailsValue = new List<ushort[]>();
                        TTD.DetailsX = new List<List<ushort>>();
                        TTD.DetailsY = new List<List<ushort>>();
                        TTD.OldDetailsValue = new List<List<ushort>>();
                        //						TTD.DetailHasProcessed = new List<List<bool>>();

                        for (int index = 0; index < TTD.DetailLayersCount; index++)
                        {
                            //							if(TTD.DetailLayersSkip.Contains(index)){ 
                            //								TTD.DetailsX.Add(new ushort[0]);
                            //								TTD.DetailsY.Add(new ushort[0]);
                            //								TTD.OldDetailsValue.Add(new ushort[0]);
                            //								continue; 
                            //							}
                            //							int detailentrycount = (int)((float)mMinMaxDetailEntryCount[index] * 1.5f);
                            //							int d_temp_Size = dSize;
                            //							if(d_temp_Size > detailentrycount){ d_temp_Size = detailentrycount; }
                            //							if(d_temp_Size < 1){ d_temp_Size = 1; }
                            //							if(d_temp_Size > (tTerrain.terrainData.detailResolution * tTerrain.terrainData.detailResolution)){
                            //								d_temp_Size = tTerrain.terrainData.detailResolution * tTerrain.terrainData.detailResolution;	
                            //							}
                            //
                            //							TTD.DetailsX.Add(new ushort[d_temp_Size]);
                            //							TTD.DetailsY.Add(new ushort[d_temp_Size]);
                            //							TTD.OldDetailsValue.Add(new ushort[d_temp_Size]);

                            TTD.DetailsX.Add(new List<ushort>());
                            TTD.DetailsY.Add(new List<ushort>());
                            TTD.OldDetailsValue.Add(new List<ushort>());
                        }


                        //						TTD.DetailsX = new ushort[TTD.DetailLayersCount,dSize];
                        //						TTD.DetailsY = new ushort[TTD.DetailLayersCount,dSize];
                        //						TTD.OldDetailsValue = new ushort[TTD.DetailLayersCount,dSize];


                    }

                    //Trees:
                    GSDRootUtil.EndStartProfiling(tRoad, "Trees");
                    if (tRoad.opt_TreeModEnabled)
                    {
                        //						TTD.TreesCurrent = tTerrain.terrainData.treeInstances;
                        TTD.TreesCurrent = new List<TreeInstance>(tTerrain.terrainData.treeInstances);
                        TTD.TreeSize = TTD.TreesCurrent.Count;
                        TTD.TreesI = 0;
                        TTD.TreesOld = new List<TreeInstance>();
                    }
                    GSDRootUtil.EndProfiling(tRoad);
                }
            }

            //Figure out relevant TTD to spline:
            List<TempTerrainData> EditorTTDList = new List<TempTerrainData>();
            if (TempTerrainDict != null)
            {
                foreach (Terrain tTerrain in tTerrains)
                {
                    if (TempTerrainDict.ContainsKey(tTerrain))
                    {
                        EditorTTDList.Add(TempTerrainDict[tTerrain]);
                    }
                }
            }

            GSDRootUtil.EndProfiling(tRoad);

            //Start job now, for each relevant TTD:
            tRoad.EditorTerrainCalcs(ref EditorTTDList);
            if (bMultithreaded)
            {
                GSD.Threaded.TerrainCalcs tJob = new GSD.Threaded.TerrainCalcs();
                tJob.Setup(ref EditorTTDList, tSpline, tRoad);
                tRoad.TerrainCalcsJob = tJob;
                tJob.Start();
            }
            else
            {
                GSD.Threaded.TerrainCalcs_Static.RunMe(ref EditorTTDList, tSpline, tRoad);
            }
        }


        public static GSDRoadUtil.Construction2DRect GetTerrainBounds(Terrain tTerrain)
        {
            float terrainWidth = tTerrain.terrainData.size.x;
            float terrainLength = tTerrain.terrainData.size.z;
            //			Vector3 tPos = tTerrain.transform.TransformPoint(tTerrain.transform.position);

            Vector3 X0 = new Vector3(0f, 0f, 0f);
            Vector3 X1 = new Vector3(terrainWidth, 0f, 0f);
            Vector3 X2 = new Vector3(terrainWidth, 0f, terrainLength);
            Vector3 X3 = new Vector3(0f, 0f, terrainLength);

            X0 = tTerrain.transform.TransformPoint(X0);
            X1 = tTerrain.transform.TransformPoint(X1);
            X2 = tTerrain.transform.TransformPoint(X2);
            X3 = tTerrain.transform.TransformPoint(X3);

            Vector2 P0 = new Vector2(X0.x, X0.z);
            Vector2 P1 = new Vector2(X1.x, X1.z);
            Vector2 P2 = new Vector2(X2.x, X2.z);
            Vector2 P3 = new Vector2(X3.x, X3.z);


            //OLD CODE:
            //Vector2 P0 = new Vector2(0f, 0f);
            //Vector2 P1 = new Vector2(terrainWidth, 0f);
            //Vector2 P2 = new Vector2(terrainWidth, terrainLength);
            //Vector2 P3 = new Vector2(0f, terrainLength);

            //P0 = tTerrain.transform.TransformPoint(P0);
            //P1 = tTerrain.transform.TransformPoint(P1);
            //P2 = tTerrain.transform.TransformPoint(P2);
            //P3 = tTerrain.transform.TransformPoint(P3);

            return new GSDRoadUtil.Construction2DRect(P0, P1, P2, P3, tTerrain.transform.position.y);
        }


        public static void ProcessRoad_Terrain_Hook2(GSDSplineC tSpline, ref List<TempTerrainData> TTDList)
        {
            GSDRootUtil.StartProfiling(tSpline.tRoad, "ProcessRoad_Terrain_Hook2");
            ProcessRoad_Terrain_Hook2_Do(ref tSpline, ref TTDList);
            GSDRootUtil.EndProfiling(tSpline.tRoad);
        }


        private static void ProcessRoad_Terrain_Hook2_Do(ref GSDSplineC tSpline, ref List<TempTerrainData> TTDList)
        {
            if (!tSpline.tRoad.opt_TreeModEnabled && !tSpline.tRoad.opt_HeightModEnabled && !tSpline.tRoad.opt_DetailModEnabled)
            {
                //Exit if no mod taking place.
                return;
            }
            Object[] TIDs = GameObject.FindObjectsOfType(typeof(GSDTerrain));
            Terrain tTerrain;
            int[,] tDetails = null;
            int IntBufferX = 0;
            int IntBufferY = 0;
            int tVal = 0;
            //			ushort Invalid = 16384;
            foreach (TempTerrainData TTD in TTDList)
            {
                foreach (GSDTerrain TID in TIDs)
                {
                    if (TID.GSDID == TTD.GSDID)
                    {
                        tTerrain = TID.transform.gameObject.GetComponent<Terrain>();
                        if (tTerrain != null)
                        {
                            //Details:
                            if (tSpline.tRoad.opt_DetailModEnabled)
                            {
                                for (int index = 0; index < TTD.DetailLayersCount; index++)
                                {
                                    //									if(TTD.DetailLayersSkip.Contains(i) || TTD.DetailValues[i] == null){ continue; }
                                    //									if(TTD.DetailsI[i] > 0){
                                    //										tTerrain.terrainData.SetDetailLayer(0,0,i,TTD.DetailValues[i]);	
                                    //									}

                                    if (TTD.DetailLayersSkip.Contains(index) || TTD.MainDetailsX == null || TTD.MainDetailsX.Count < 1)
                                    {
                                        continue;
                                    }
                                    tDetails = tTerrain.terrainData.GetDetailLayer(0, 0, TTD.DetailMaxIndex, TTD.DetailMaxIndex, index);

                                    int MaxCount = TTD.MainDetailsX.Count;
                                    for (int j = 0; j < MaxCount; j++)
                                    {
                                        IntBufferX = TTD.MainDetailsX[j];
                                        IntBufferY = TTD.MainDetailsY[j];
                                        tVal = tDetails[IntBufferX, IntBufferY];
                                        if (tVal > 0)
                                        {
                                            TTD.DetailsX[index].Add((ushort) IntBufferX);
                                            TTD.DetailsY[index].Add((ushort) IntBufferY);
                                            TTD.OldDetailsValue[index].Add((ushort) tVal);
                                            tDetails[IntBufferX, IntBufferY] = 0;
                                        }
                                    }
                                    TTD.DetailsI[index] = TTD.DetailsX[index].Count;

                                    tTerrain.terrainData.SetDetailLayer(0, 0, index, tDetails);
                                    tDetails = null;
                                    TTD.DetailHasProcessed = null;
                                }
                                TTD.MainDetailsX = null;
                                TTD.MainDetailsY = null;
                                System.GC.Collect();
                            }
                            //Trees:
                            if (tSpline.tRoad.opt_TreeModEnabled && TTD.TreesCurrent != null && TTD.TreesI > 0)
                            {
                                tTerrain.terrainData.treeInstances = TTD.TreesCurrent.ToArray();
                            }
                            //Heights:
                            if (tSpline.tRoad.opt_HeightModEnabled && TTD.heights != null && TTD.cI > 0)
                            {
                                //Do heights last to trigger collisions and stuff properly:
                                tTerrain.terrainData.SetHeights(0, 0, TTD.heights);
                            }
                        }
                    }
                }
            }
        }


        public static void TerrainsReset(GSDRoad tRoad)
        {
            TerrainsReset_Do(ref tRoad);
        }


        private static void TerrainsReset_Do(ref GSDRoad tRoad)
        {
            if (tRoad.TerrainHistory == null)
            {
                return;
            }
            if (tRoad.TerrainHistory.Count < 1)
            {
                return;
            }

            Object[] TIDs = GameObject.FindObjectsOfType(typeof(GSDTerrain));
            float[,] heights;
            int[,] tDetails;
            int ArrayCount;
            foreach (GSDTerrainHistoryMaker TH in tRoad.TerrainHistory)
            {
                Terrain tTerrain = null;
                foreach (GSDTerrain TID in TIDs)
                {
                    if (TID.GSDID == TH.TID)
                    {
                        tTerrain = TID.tTerrain;
                    }
                }
                if (!tTerrain)
                {
                    continue;
                }

                //Heights:
                if (TH.x1 != null)
                {
                    heights = tTerrain.terrainData.GetHeights(0, 0, tTerrain.terrainData.heightmapWidth, tTerrain.terrainData.heightmapHeight);
                    ArrayCount = TH.cI;
                    for (int index = 0; index < ArrayCount; index++)
                    {
                        heights[TH.x1[index], TH.y1[index]] = TH.h[index];
                    }
                    tTerrain.terrainData.SetHeights(0, 0, heights);
                }
                //Details:
                if (TH.DetailsI != null && TH.DetailsX != null && TH.DetailsY != null && TH.DetailsOldValue != null)
                {
                    int RealLayerCount = tTerrain.terrainData.detailPrototypes.Length;
                    int StartIndex = 0;
                    int EndIndex = 0;
                    for (int index = 0; index < TH.DetailLayersCount; index++)
                    {
                        if (index >= RealLayerCount)
                        {
                            break;
                        }
                        if (TH.DetailsX.Length <= index)
                        {
                            break;
                        }
                        if (TH.DetailsY.Length <= index)
                        {
                            break;
                        }
                        if (TH.DetailsX == null || TH.DetailsY == null || TH.DetailsI == null || TH.DetailsX.Length < 1)
                        {
                            continue;
                        }

                        tDetails = tTerrain.terrainData.GetDetailLayer(0, 0, tTerrain.terrainData.detailWidth, tTerrain.terrainData.detailHeight, index);
                        ArrayCount = TH.DetailsI[index];
                        if (ArrayCount == 0)
                        {
                            continue;
                        }
                        EndIndex += ArrayCount;
                        for (int j = StartIndex; j < EndIndex; j++)
                        {
                            tDetails[TH.DetailsX[j], TH.DetailsY[j]] = TH.DetailsOldValue[j];
                        }
                        StartIndex = EndIndex;
                        tTerrain.terrainData.SetDetailLayer(0, 0, index, tDetails);
                        tDetails = null;
                    }
                }
                //Trees:
                TreeInstance[] xTress = TH.MakeTrees();
                if (xTress != null)
                {
                    ArrayCount = xTress.Length;
                    if (ArrayCount > 0 && TH.TreesOld != null)
                    {
                        int TerrainTreeCount = tTerrain.terrainData.treeInstances.Length;
                        ;
                        TreeInstance[] tTrees = new TreeInstance[ArrayCount + TerrainTreeCount];
                        System.Array.Copy(tTerrain.terrainData.treeInstances, 0, tTrees, 0, TerrainTreeCount);
                        System.Array.Copy(xTress, 0, tTrees, TerrainTreeCount, ArrayCount);
                        tTerrain.terrainData.treeInstances = tTrees;
                    }
                    xTress = null;
                }
            }
            System.GC.Collect();
        }
    }


    [System.Serializable]
    public class GSDTerrainHistoryMaker
    {
        public int TID;
        //Heights:
        public int[] x1;
        public int[] y1;
        public float[] h;
        public int cI;
        public bool bHeightHistoryEnabled;
        //Details:
        public int DetailLayersCount;

        public int[] DetailsX;
        public int[] DetailsY;
        public int[] DetailsOldValue;
        public int[] DetailsI;

        public bool bDetailHistoryEnabled;
        //Trees:
        public GSDTreeInstance[] TreesOld;
        public int TreesI;
        public bool bTreeHistoryEnabled;
        public bool bDestroyMe = false;


        public void Nullify()
        {
            //Heights:
            x1 = null;
            y1 = null;
            h = null;
            DetailsX = null;
            DetailsY = null;
            DetailsOldValue = null;
            DetailsI = null;
            //Trees:
            TreesOld = null;
        }


        [System.Serializable]
        public class GSDTreeInstance
        {
            public float colorR;//4
            public float colorG;//8
            public float colorB;//12
            public float colorA;//16
            public float heightScale;//20
            public float lightmapColorR;//24
            public float lightmapColorG;//28
            public float lightmapColorB;//32
            public float lightmapColorA;//36
            public float positionX;//40
            public float positionY;//44
            public float positionZ;//48
            public int prototypeIndex;//52
            public float widthScale;//56
        }


        public void MakeGSDTrees(ref List<TreeInstance> tTrees)
        {
            int tSize = tTrees.Count;
            TreesOld = new GSDTreeInstance[tSize];
            GSDTreeInstance tTree = null;
            TreeInstance xTree;
            for (int index = 0; index < tSize; index++)
            {
                xTree = tTrees[index];
                tTree = new GSDTreeInstance();
                tTree.colorR = xTree.color.r;
                tTree.colorG = xTree.color.g;
                tTree.colorB = xTree.color.b;
                tTree.colorA = xTree.color.a;
                tTree.heightScale = xTree.heightScale;
                tTree.lightmapColorR = xTree.lightmapColor.r;
                tTree.lightmapColorG = xTree.lightmapColor.g;
                tTree.lightmapColorB = xTree.lightmapColor.b;
                tTree.lightmapColorA = xTree.lightmapColor.a;
                tTree.positionX = xTree.position.x;
                tTree.positionY = xTree.position.y;
                tTree.positionZ = xTree.position.z;
                tTree.prototypeIndex = xTree.prototypeIndex;
                tTree.widthScale = xTree.widthScale;
                TreesOld[index] = tTree;
            }
        }


        public TreeInstance[] MakeTrees()
        {
            if (TreesOld == null || TreesOld.Length < 1)
            {
                return null;
            }
            int tSize = TreesOld.Length;
            TreeInstance[] tTrees = new TreeInstance[tSize];
            GSDTreeInstance tTree = null;
            TreeInstance xTree;
            for (int index = 0; index < tSize; index++)
            {
                tTree = TreesOld[index];
                xTree = new TreeInstance();
                xTree.color = new Color(tTree.colorR, tTree.colorG, tTree.colorB, tTree.colorA);
                xTree.heightScale = tTree.heightScale;
                xTree.lightmapColor = new Color(tTree.lightmapColorR, tTree.lightmapColorG, tTree.lightmapColorB, tTree.lightmapColorA);
                xTree.position = new Vector3(tTree.positionX, tTree.positionY, tTree.positionZ);
                xTree.prototypeIndex = tTree.prototypeIndex;
                xTree.widthScale = tTree.widthScale;
                tTrees[index] = xTree;
            }
            return tTrees;
        }


        public int GetSize()
        {
            int tSize = 4;
            if (x1 != null)
            {
                tSize += (x1.Length * 4);
                tSize += 20;
            }
            if (y1 != null)
            {
                tSize += (y1.Length * 4);
                tSize += 20;
            }
            if (h != null)
            {
                tSize += (h.Length * 4);
                tSize += 20;
            }
            tSize += 4;
            tSize += 1;
            //Details:
            tSize += 4;
            if (DetailsX != null)
            {
                tSize += (DetailsX.Length * 4);
                tSize += 20;
            }
            if (DetailsY != null)
            {
                tSize += (DetailsY.Length * 4);
                tSize += 20;
            }
            if (DetailsOldValue != null)
            {
                tSize += (DetailsOldValue.Length * 4);
                tSize += 20;
            }
            if (DetailsI != null)
            {
                tSize += (DetailsI.Length * 4);
                tSize += 20;
            }
            tSize += 1;
            //Trees:
            if (TreesOld != null)
            {
                tSize += (TreesOld.Length * 56);
                tSize += 20;
            }
            tSize += 4;
            tSize += 1;
            tSize += 1;

            return tSize;
        }
    }


    public class RoadConstructorBufferMaker
    {
        public GSDRoad tRoad;

        public List<Vector3> RoadVectors;
        public List<Vector3> ShoulderR_Vectors;
        public List<Vector3> ShoulderL_Vectors;

        public int[] tris;
        public int[] tris_ShoulderR;
        public int[] tris_ShoulderL;

        public Vector3[] normals;
        public Vector3[] normals_ShoulderR;
        public Vector3[] normals_ShoulderL;
        public List<int> normals_ShoulderR_averageStartIndexes;
        public List<int> normals_ShoulderL_averageStartIndexes;

        public Vector2[] uv;
        public Vector2[] uv2;
        public Vector2[] uv_SR;
        public Vector2[] uv_SL;

        public Vector4[] tangents;
        public Vector4[] tangents2;
        public Vector4[] tangents_SR;
        public Vector4[] tangents_SL;

        public List<List<Vector3>> cut_RoadVectors;
        public List<Vector3> cut_RoadVectorsHome;
        public List<List<Vector3>> cut_ShoulderR_Vectors;
        public List<List<Vector3>> cut_ShoulderL_Vectors;
        public List<Vector3> cut_ShoulderR_VectorsHome;
        public List<Vector3> cut_ShoulderL_VectorsHome;
        public List<int[]> cut_tris;
        public List<int[]> cut_tris_ShoulderR;
        public List<int[]> cut_tris_ShoulderL;
        public List<Vector3[]> cut_normals;
        public List<Vector3[]> cut_normals_ShoulderR;
        public List<Vector3[]> cut_normals_ShoulderL;
        public List<Vector2[]> cut_uv;
        public List<Vector2[]> cut_uv_SR;
        public List<Vector2[]> cut_uv_SL;
        public List<Vector4[]> cut_tangents;
        public List<Vector4[]> cut_tangents_SR;
        public List<Vector4[]> cut_tangents_SL;

        public List<Vector2[]> cut_uv_world;
        public List<Vector2[]> cut_uv_SR_world;
        public List<Vector2[]> cut_uv_SL_world;
        public List<Vector4[]> cut_tangents_world;
        public List<Vector4[]> cut_tangents_SR_world;
        public List<Vector4[]> cut_tangents_SL_world;

        //Road connections:
        public List<Vector3[]> RoadConnections_verts;
        public List<int[]> RoadConnections_tris;
        public List<Vector3[]> RoadConnections_normals;
        public List<Vector2[]> RoadConnections_uv;
        public List<Vector4[]> RoadConnections_tangents;

        //Back lanes:
        public List<Vector3[]> iBLane0s;
        public List<Vector3[]> iBLane1s;
        public List<bool> iBLane1s_IsMiddleLane;
        public List<Vector3[]> iBLane2s;
        public List<Vector3[]> iBLane3s;
        //Front lanes:
        public List<Vector3[]> iFLane0s;
        public List<Vector3[]> iFLane1s;
        public List<bool> iFLane1s_IsMiddleLane;
        public List<Vector3[]> iFLane2s;
        public List<Vector3[]> iFLane3s;
        //Main plates:
        public List<Vector3[]> iBMainPlates;
        public List<Vector3[]> iFMainPlates;
        //Marker plates:
        public List<Vector3[]> iBMarkerPlates;
        public List<Vector3[]> iFMarkerPlates;

        //Back lanes:
        public List<int[]> iBLane0s_tris;
        public List<int[]> iBLane1s_tris;
        public List<int[]> iBLane2s_tris;
        public List<int[]> iBLane3s_tris;
        //Front lanes:
        public List<int[]> iFLane0s_tris;
        public List<int[]> iFLane1s_tris;
        public List<int[]> iFLane2s_tris;
        public List<int[]> iFLane3s_tris;
        //Main plates:
        public List<int[]> iBMainPlates_tris;
        public List<int[]> iFMainPlates_tris;
        //Marker plates:
        public List<int[]> iBMarkerPlates_tris;
        public List<int[]> iFMarkerPlates_tris;

        //Back lanes:
        public List<Vector3[]> iBLane0s_normals;
        public List<Vector3[]> iBLane1s_normals;
        public List<Vector3[]> iBLane2s_normals;
        public List<Vector3[]> iBLane3s_normals;
        //Front lanes:
        public List<Vector3[]> iFLane0s_normals;
        public List<Vector3[]> iFLane1s_normals;
        public List<Vector3[]> iFLane2s_normals;
        public List<Vector3[]> iFLane3s_normals;
        //Main plates:
        public List<Vector3[]> iBMainPlates_normals;
        public List<Vector3[]> iFMainPlates_normals;
        //Marker plates:
        public List<Vector3[]> iBMarkerPlates_normals;
        public List<Vector3[]> iFMarkerPlates_normals;

        //Back lanes:
        public List<GSDRoadIntersection> iBLane0s_tID;
        public List<GSDRoadIntersection> iBLane1s_tID;
        public List<GSDRoadIntersection> iBLane2s_tID;
        public List<GSDRoadIntersection> iBLane3s_tID;
        //Front lanes:
        public List<GSDRoadIntersection> iFLane0s_tID;
        public List<GSDRoadIntersection> iFLane1s_tID;
        public List<GSDRoadIntersection> iFLane2s_tID;
        public List<GSDRoadIntersection> iFLane3s_tID;
        //Main plates:
        public List<GSDRoadIntersection> iBMainPlates_tID;
        public List<GSDRoadIntersection> iFMainPlates_tID;
        //Marker plates:
        public List<GSDRoadIntersection> iBMarkerPlates_tID;
        public List<GSDRoadIntersection> iFMarkerPlates_tID;

        //Back lanes:
        public List<GSDSplineN> iBLane0s_nID;
        public List<GSDSplineN> iBLane1s_nID;
        public List<GSDSplineN> iBLane2s_nID;
        public List<GSDSplineN> iBLane3s_nID;
        //Front lanes:
        public List<GSDSplineN> iFLane0s_nID;
        public List<GSDSplineN> iFLane1s_nID;
        public List<GSDSplineN> iFLane2s_nID;
        public List<GSDSplineN> iFLane3s_nID;
        //Main plates:
        public List<GSDSplineN> iBMainPlates_nID;
        public List<GSDSplineN> iFMainPlates_nID;
        //Marker plates:
        public List<GSDSplineN> iBMarkerPlates_nID;
        public List<GSDSplineN> iFMarkerPlates_nID;

        //Back lanes:
        public List<Vector2[]> iBLane0s_uv;
        public List<Vector2[]> iBLane1s_uv;
        public List<Vector2[]> iBLane2s_uv;
        public List<Vector2[]> iBLane3s_uv;
        //Front lanes:
        public List<Vector2[]> iFLane0s_uv;
        public List<Vector2[]> iFLane1s_uv;
        public List<Vector2[]> iFLane2s_uv;
        public List<Vector2[]> iFLane3s_uv;
        //Main plates:
        public List<Vector2[]> iBMainPlates_uv;
        public List<Vector2[]> iFMainPlates_uv;
        public List<Vector2[]> iBMainPlates_uv2;
        public List<Vector2[]> iFMainPlates_uv2;
        //Marker plates:
        public List<Vector2[]> iBMarkerPlates_uv;
        public List<Vector2[]> iFMarkerPlates_uv;

        //Back lanes:
        public List<Vector4[]> iBLane0s_tangents;
        public List<Vector4[]> iBLane1s_tangents;
        public List<Vector4[]> iBLane2s_tangents;
        public List<Vector4[]> iBLane3s_tangents;
        //Front lanes:
        public List<Vector4[]> iFLane0s_tangents;
        public List<Vector4[]> iFLane1s_tangents;
        public List<Vector4[]> iFLane2s_tangents;
        public List<Vector4[]> iFLane3s_tangents;
        //Main plates:
        public List<Vector4[]> iBMainPlates_tangents;
        public List<Vector4[]> iFMainPlates_tangents;
        public List<Vector4[]> iBMainPlates_tangents2;
        public List<Vector4[]> iFMainPlates_tangents2;
        //Marker plates:
        public List<Vector4[]> iBMarkerPlates_tangents;
        public List<Vector4[]> iFMarkerPlates_tangents;

        public Terrain tTerrain;

        public List<GSD.Roads.GSDRoadUtil.Construction2DRect> tIntersectionBounds;
        public HashSet<Vector3> ImmuneVects;

        public Mesh tMesh;
        public Mesh tMesh_SR;
        public Mesh tMesh_SL;
        public bool tMeshSkip = false;
        public bool tMesh_SRSkip = false;
        public bool tMesh_SLSkip = false;
        public List<Mesh> tMesh_RoadCuts;
        public List<Mesh> tMesh_SRCuts;
        public List<Mesh> tMesh_SLCuts;
        public List<Mesh> tMesh_RoadCuts_world;
        public List<Mesh> tMesh_SRCuts_world;
        public List<Mesh> tMesh_SLCuts_world;

        public List<Mesh> tMesh_RoadConnections;

        public List<Mesh> tMesh_iBLanes0;
        public List<Mesh> tMesh_iBLanes1;
        public List<Mesh> tMesh_iBLanes2;
        public List<Mesh> tMesh_iBLanes3;
        public List<Mesh> tMesh_iFLanes0;
        public List<Mesh> tMesh_iFLanes1;
        public List<Mesh> tMesh_iFLanes2;
        public List<Mesh> tMesh_iFLanes3;
        public List<Mesh> tMesh_iBMainPlates;
        public List<Mesh> tMesh_iFMainPlates;
        public List<Mesh> tMesh_iBMarkerPlates;
        public List<Mesh> tMesh_iFMarkerPlates;

        public RoadUpdateTypeEnum tUpdateType;

        public bool bRoadOn = true;
        public bool bTerrainOn = true;
        public bool bBridgesOn = true;
        public bool bInterseOn = true;

        public List<int> RoadCuts;
        public List<GSDSplineN> RoadCutNodes;
        public List<int> ShoulderCutsR;
        public List<GSDSplineN> ShoulderCutsRNodes;
        public List<int> ShoulderCutsL;
        public List<GSDSplineN> ShoulderCutsLNodes;

        public enum SaveMeshTypeEnum { Road, Shoulder, Intersection, Railing, Center, Bridge, RoadCut, SCut, BSCut, RoadConn };


        public RoadConstructorBufferMaker(GSDRoad _tRoad, RoadUpdateTypeEnum _tUpdateType)
        {
            tUpdateType = _tUpdateType;
            bRoadOn = (tUpdateType == RoadUpdateTypeEnum.Full || tUpdateType == RoadUpdateTypeEnum.Intersection || tUpdateType == RoadUpdateTypeEnum.Bridges);
            bTerrainOn = (tUpdateType == RoadUpdateTypeEnum.Full || tUpdateType == RoadUpdateTypeEnum.Intersection || tUpdateType == RoadUpdateTypeEnum.Bridges);
            bBridgesOn = (tUpdateType == RoadUpdateTypeEnum.Full || tUpdateType == RoadUpdateTypeEnum.Bridges);
            bInterseOn = (tUpdateType == RoadUpdateTypeEnum.Full || tUpdateType == RoadUpdateTypeEnum.Intersection);

            tRoad = _tRoad;
            Nullify();
            RoadVectors = new List<Vector3>();
            ShoulderR_Vectors = new List<Vector3>();
            ShoulderL_Vectors = new List<Vector3>();
            normals_ShoulderR_averageStartIndexes = new List<int>();
            normals_ShoulderL_averageStartIndexes = new List<int>();

            cut_RoadVectors = new List<List<Vector3>>();
            cut_RoadVectorsHome = new List<Vector3>();
            cut_ShoulderR_Vectors = new List<List<Vector3>>();
            cut_ShoulderL_Vectors = new List<List<Vector3>>();
            cut_ShoulderR_VectorsHome = new List<Vector3>();
            cut_ShoulderL_VectorsHome = new List<Vector3>();
            cut_tris = new List<int[]>();
            cut_tris_ShoulderR = new List<int[]>();
            cut_tris_ShoulderL = new List<int[]>();
            cut_normals = new List<Vector3[]>();
            cut_normals_ShoulderR = new List<Vector3[]>();
            cut_normals_ShoulderL = new List<Vector3[]>();
            cut_uv = new List<Vector2[]>();
            cut_uv_SR = new List<Vector2[]>();
            cut_uv_SL = new List<Vector2[]>();
            cut_tangents = new List<Vector4[]>();
            cut_tangents_SR = new List<Vector4[]>();
            cut_tangents_SL = new List<Vector4[]>();

            cut_uv_world = new List<Vector2[]>();
            cut_uv_SR_world = new List<Vector2[]>();
            cut_uv_SL_world = new List<Vector2[]>();
            cut_tangents_world = new List<Vector4[]>();
            cut_tangents_SR_world = new List<Vector4[]>();
            cut_tangents_SL_world = new List<Vector4[]>();

            RoadCutNodes = new List<GSDSplineN>();
            ShoulderCutsRNodes = new List<GSDSplineN>();
            ShoulderCutsLNodes = new List<GSDSplineN>();

            RoadConnections_verts = new List<Vector3[]>();
            RoadConnections_tris = new List<int[]>();
            RoadConnections_normals = new List<Vector3[]>();
            RoadConnections_uv = new List<Vector2[]>();
            RoadConnections_tangents = new List<Vector4[]>();

            RoadCuts = new List<int>();
            ShoulderCutsR = new List<int>();
            ShoulderCutsL = new List<int>();

            //if(bInterseOn){
            //Back lanes:
            iBLane0s = new List<Vector3[]>();
            iBLane1s = new List<Vector3[]>();
            iBLane2s = new List<Vector3[]>();
            iBLane3s = new List<Vector3[]>();
            //Front lanes:
            iFLane0s = new List<Vector3[]>();
            iFLane1s = new List<Vector3[]>();
            iFLane2s = new List<Vector3[]>();
            iFLane3s = new List<Vector3[]>();
            //Main plates:
            iBMainPlates = new List<Vector3[]>();
            iFMainPlates = new List<Vector3[]>();
            //Marker plates:
            iBMarkerPlates = new List<Vector3[]>();
            iFMarkerPlates = new List<Vector3[]>();

            //Back lanes:
            iBLane0s_tris = new List<int[]>();
            iBLane1s_tris = new List<int[]>();
            iBLane2s_tris = new List<int[]>();
            iBLane3s_tris = new List<int[]>();
            //Front lanes:
            iFLane0s_tris = new List<int[]>();
            iFLane1s_tris = new List<int[]>();
            iFLane2s_tris = new List<int[]>();
            iFLane3s_tris = new List<int[]>();
            //Main plates:
            iBMainPlates_tris = new List<int[]>();
            iFMainPlates_tris = new List<int[]>();
            //Marker plates:
            iBMarkerPlates_tris = new List<int[]>();
            iFMarkerPlates_tris = new List<int[]>();

            //Back lanes:
            iBLane0s_normals = new List<Vector3[]>();
            iBLane1s_normals = new List<Vector3[]>();
            iBLane2s_normals = new List<Vector3[]>();
            iBLane3s_normals = new List<Vector3[]>();
            //Front lanes:
            iFLane0s_normals = new List<Vector3[]>();
            iFLane1s_normals = new List<Vector3[]>();
            iFLane2s_normals = new List<Vector3[]>();
            iFLane3s_normals = new List<Vector3[]>();
            //Main plates:
            iBMainPlates_normals = new List<Vector3[]>();
            iFMainPlates_normals = new List<Vector3[]>();
            //Marker plates:
            iBMarkerPlates_normals = new List<Vector3[]>();
            iFMarkerPlates_normals = new List<Vector3[]>();

            //Back lanes:
            iBLane0s_uv = new List<Vector2[]>();
            iBLane1s_uv = new List<Vector2[]>();
            iBLane2s_uv = new List<Vector2[]>();
            iBLane3s_uv = new List<Vector2[]>();
            //Front lanes:
            iFLane0s_uv = new List<Vector2[]>();
            iFLane1s_uv = new List<Vector2[]>();
            iFLane2s_uv = new List<Vector2[]>();
            iFLane3s_uv = new List<Vector2[]>();
            //Main plates:
            iBMainPlates_uv = new List<Vector2[]>();
            iFMainPlates_uv = new List<Vector2[]>();
            iBMainPlates_uv2 = new List<Vector2[]>();
            iFMainPlates_uv2 = new List<Vector2[]>();
            //Marker plates:
            iBMarkerPlates_uv = new List<Vector2[]>();
            iFMarkerPlates_uv = new List<Vector2[]>();

            //Back lanes:
            iBLane0s_tangents = new List<Vector4[]>();
            iBLane1s_tangents = new List<Vector4[]>();
            iBLane2s_tangents = new List<Vector4[]>();
            iBLane3s_tangents = new List<Vector4[]>();
            //Front lanes:
            iFLane0s_tangents = new List<Vector4[]>();
            iFLane1s_tangents = new List<Vector4[]>();
            iFLane2s_tangents = new List<Vector4[]>();
            iFLane3s_tangents = new List<Vector4[]>();
            //Main plates:
            iBMainPlates_tangents = new List<Vector4[]>();
            iFMainPlates_tangents = new List<Vector4[]>();
            iBMainPlates_tangents2 = new List<Vector4[]>();
            iFMainPlates_tangents2 = new List<Vector4[]>();
            //Marker plates:
            iBMarkerPlates_tangents = new List<Vector4[]>();
            iFMarkerPlates_tangents = new List<Vector4[]>();

            iFLane1s_IsMiddleLane = new List<bool>();
            iBLane1s_IsMiddleLane = new List<bool>();

            //Back lanes:
            iBLane0s_tID = new List<GSDRoadIntersection>();
            iBLane1s_tID = new List<GSDRoadIntersection>();
            iBLane2s_tID = new List<GSDRoadIntersection>();
            iBLane3s_tID = new List<GSDRoadIntersection>();
            //Front lanes:
            iFLane0s_tID = new List<GSDRoadIntersection>();
            iFLane1s_tID = new List<GSDRoadIntersection>();
            iFLane2s_tID = new List<GSDRoadIntersection>();
            iFLane3s_tID = new List<GSDRoadIntersection>();
            //Main plates:
            iBMainPlates_tID = new List<GSDRoadIntersection>();
            iFMainPlates_tID = new List<GSDRoadIntersection>();
            //Marker plates:
            iBMarkerPlates_tID = new List<GSDRoadIntersection>();
            iFMarkerPlates_tID = new List<GSDRoadIntersection>();

            iBLane0s_nID = new List<GSDSplineN>();
            iBLane1s_nID = new List<GSDSplineN>();
            iBLane2s_nID = new List<GSDSplineN>();
            iBLane3s_nID = new List<GSDSplineN>();
            //Front lanes:
            iFLane0s_nID = new List<GSDSplineN>();
            iFLane1s_nID = new List<GSDSplineN>();
            iFLane2s_nID = new List<GSDSplineN>();
            iFLane3s_nID = new List<GSDSplineN>();
            //Main plates:
            iBMainPlates_nID = new List<GSDSplineN>();
            iFMainPlates_nID = new List<GSDSplineN>();
            //Marker plates:
            iBMarkerPlates_nID = new List<GSDSplineN>();
            iFMarkerPlates_nID = new List<GSDSplineN>();
            //}

            tTerrain = null;

            tMesh = new Mesh();
            tMesh_SR = new Mesh();
            tMesh_SL = new Mesh();
            tMesh_RoadCuts = new List<Mesh>();
            tMesh_SRCuts = new List<Mesh>();
            tMesh_SLCuts = new List<Mesh>();
            tMesh_RoadCuts_world = new List<Mesh>();
            tMesh_SRCuts_world = new List<Mesh>();
            tMesh_SLCuts_world = new List<Mesh>();

            tMesh_RoadConnections = new List<Mesh>();

            //if(bInterseOn){
            tMesh_iBLanes0 = new List<Mesh>();
            tMesh_iBLanes1 = new List<Mesh>();
            tMesh_iBLanes2 = new List<Mesh>();
            tMesh_iBLanes3 = new List<Mesh>();
            tMesh_iFLanes0 = new List<Mesh>();
            tMesh_iFLanes1 = new List<Mesh>();
            tMesh_iFLanes2 = new List<Mesh>();
            tMesh_iFLanes3 = new List<Mesh>();
            tMesh_iBMainPlates = new List<Mesh>();
            tMesh_iFMainPlates = new List<Mesh>();
            tMesh_iBMarkerPlates = new List<Mesh>();
            tMesh_iFMarkerPlates = new List<Mesh>();
            tIntersectionBounds = new List<GSD.Roads.GSDRoadUtil.Construction2DRect>();
            ImmuneVects = new HashSet<Vector3>();
            //}

            InitGameObjects();
        }


        #region "Init and nullify"
        private void InitGameObjects()
        {
            //Destry past objects:
            if (tRoad.MainMeshes != null)
            {
                MeshFilter[] MFArray = tRoad.MainMeshes.GetComponentsInChildren<MeshFilter>();
                MeshCollider[] MCArray = tRoad.MainMeshes.GetComponentsInChildren<MeshCollider>();

                int MFArrayCount = MFArray.Length;
                int MCArrayCount = MCArray.Length;
                for (int index = (MFArrayCount - 1); index > -1; index--)
                {
                    MFArray[index].sharedMesh = null;
                }
                for (int index = (MCArrayCount - 1); index > -1; index--)
                {
                    MCArray[index].sharedMesh = null;
                }

                Object.DestroyImmediate(tRoad.MainMeshes);
            }

            //Main mesh object:
            tRoad.MainMeshes = new GameObject("MainMeshes");
            tRoad.MainMeshes.transform.parent = tRoad.transform;

            //Road and shoulders:
            tRoad.MeshRoad = new GameObject("RoadMesh");
            tRoad.MeshShoR = new GameObject("ShoulderR");
            tRoad.MeshShoL = new GameObject("ShoulderL");
            tRoad.MeshRoad.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshShoR.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshShoL.transform.parent = tRoad.MainMeshes.transform;

            //Intersections:
            tRoad.MeshiLanes = new GameObject("MeshiLanes");
            tRoad.MeshiLanes0 = new GameObject("MeshiLanes0");
            tRoad.MeshiLanes1 = new GameObject("MeshiLanes1");
            tRoad.MeshiLanes2 = new GameObject("MeshiLanes2");
            tRoad.MeshiLanes3 = new GameObject("MeshiLanes3");
            tRoad.MeshiMainPlates = new GameObject("MeshiMainPlates");
            tRoad.MeshiMarkerPlates = new GameObject("MeshiMarkerPlates");
            tRoad.MeshiLanes.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiLanes0.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiLanes1.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiLanes2.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiLanes3.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiMainPlates.transform.parent = tRoad.MainMeshes.transform;
            tRoad.MeshiMarkerPlates.transform.parent = tRoad.MainMeshes.transform;
        }


        public void Nullify()
        {
            RoadVectors = null;
            ShoulderR_Vectors = null;
            ShoulderL_Vectors = null;
            tris = null;
            normals = null;
            uv = null;
            uv_SR = null;
            uv_SL = null;
            tangents = null;
            tangents_SR = null;
            tangents_SL = null;
            tTerrain = null;
            tIntersectionBounds = null;
            ImmuneVects = null;
            iBLane0s = null;
            iBLane1s = null;
            iBLane2s = null;
            iBLane3s = null;
            iFLane0s = null;
            iFLane1s = null;
            iFLane2s = null;
            iFLane3s = null;
            iBMainPlates = null;
            iFMainPlates = null;
            iBMarkerPlates = null;
            iFMarkerPlates = null;
            tMesh = null;
            tMesh_SR = null;
            tMesh_SL = null;
            if (tMesh_iBLanes0 != null)
            {
                tMesh_iBLanes0.Clear();
                tMesh_iBLanes0 = null;
            }
            if (tMesh_iBLanes1 != null)
            {
                tMesh_iBLanes1.Clear();
                tMesh_iBLanes1 = null;
            }
            if (tMesh_iBLanes2 != null)
            {
                tMesh_iBLanes2.Clear();
                tMesh_iBLanes2 = null;
            }
            if (tMesh_iBLanes3 != null)
            {
                tMesh_iBLanes3.Clear();
                tMesh_iBLanes3 = null;
            }
            if (tMesh_iFLanes0 != null)
            {
                tMesh_iFLanes0.Clear();
                tMesh_iFLanes0 = null;
            }
            if (tMesh_iFLanes1 != null)
            {
                tMesh_iFLanes1.Clear();
                tMesh_iFLanes1 = null;
            }
            if (tMesh_iFLanes2 != null)
            {
                tMesh_iFLanes2.Clear();
                tMesh_iFLanes2 = null;
            }
            if (tMesh_iFLanes3 != null)
            {
                tMesh_iFLanes3.Clear();
                tMesh_iFLanes3 = null;
            }
            if (tMesh_iBMainPlates != null)
            {
                tMesh_iBMainPlates.Clear();
                tMesh_iBMainPlates = null;
            }
            if (tMesh_iFMainPlates != null)
            {
                tMesh_iFMainPlates.Clear();
                tMesh_iFMainPlates = null;
            }
            if (tMesh_iBMarkerPlates != null)
            {
                tMesh_iBMarkerPlates.Clear();
                tMesh_iBMarkerPlates = null;
            }
            if (tMesh_iFMarkerPlates != null)
            {
                tMesh_iFMarkerPlates.Clear();
                tMesh_iFMarkerPlates = null;
            }
            tMesh_RoadConnections = null;

            iFLane1s_IsMiddleLane = null;
            iBLane1s_IsMiddleLane = null;

            RoadConnections_verts = null;
            RoadConnections_tris = null;
            RoadConnections_normals = null;
            RoadConnections_uv = null;
            RoadConnections_tangents = null;

            if (cut_uv_world != null)
            {
                cut_uv_world.Clear();
                cut_uv_world = null;
            }
            if (cut_uv_SR_world != null)
            {
                cut_uv_SR_world.Clear();
                cut_uv_SR_world = null;
            }
            if (cut_uv_SL_world != null)
            {
                cut_uv_SL_world.Clear();
                cut_uv_SL_world = null;
            }
            if (cut_tangents_world != null)
            {
                cut_tangents_world.Clear();
                cut_tangents_world = null;
            }
            if (cut_tangents_SR_world != null)
            {
                cut_tangents_SR_world.Clear();
                cut_tangents_SR_world = null;
            }
            if (cut_tangents_SL_world != null)
            {
                cut_tangents_SL_world.Clear();
                cut_tangents_SL_world = null;
            }


            tMesh = null;
            tMesh_SR = null;
            tMesh_SL = null;
            tMesh_SR = null;
            tMesh_SL = null;
            tMesh_RoadCuts = null;
            tMesh_SRCuts = null;
            tMesh_SLCuts = null;
            tMesh_RoadCuts_world = null;
            tMesh_SRCuts_world = null;
            tMesh_SLCuts_world = null;
        }
        #endregion


        #region "Mesh Setup1"	
        public void MeshSetup1()
        {
            MeshSetup1_Do();
        }


        /// <summary>
        /// Creates meshes and assigns vertices, triangles and normals. If multithreading enabled, this occurs inbetween threaded jobs since unity library can't be used in threads.
        /// </summary>
        private void MeshSetup1_Do()
        {
            Mesh MeshBuffer = null;

            if (bInterseOn)
            {
                MeshSetup1_IntersectionObjectsSetup();
            }

            if (bRoadOn)
            {
                //Main road:
                if (RoadVectors.Count < 64000)
                {
                    if (tMesh == null)
                    {
                        tMesh = new Mesh();
                    }
                    tMesh = MeshSetup1_Helper(ref tMesh, RoadVectors.ToArray(), ref tris, ref normals);
                    tMeshSkip = false;
                }
                else
                {
                    tMeshSkip = true;
                }

                //Right shoulder:
                if (ShoulderR_Vectors.Count < 64000)
                {
                    if (tMesh_SR == null)
                    {
                        tMesh_SR = new Mesh();
                    }
                    tMesh_SR = MeshSetup1_Helper(ref tMesh_SR, ShoulderR_Vectors.ToArray(), ref tris_ShoulderR, ref normals_ShoulderR);
                    tMesh_SRSkip = false;
                }
                else
                {
                    tMesh_SRSkip = true;
                }

                //Left shoulder:
                if (ShoulderL_Vectors.Count < 64000)
                {
                    if (tMesh_SL == null)
                    {
                        tMesh_SL = new Mesh();
                    }
                    tMesh_SL = MeshSetup1_Helper(ref tMesh_SL, ShoulderL_Vectors.ToArray(), ref tris_ShoulderL, ref normals_ShoulderL);
                    tMesh_SLSkip = false;
                }
                else
                {
                    tMesh_SLSkip = true;
                }

                if (RoadConnections_verts.Count > 0)
                {
                    Mesh qMesh = null;
                    for (int index = 0; index < RoadConnections_verts.Count; index++)
                    {
                        qMesh = new Mesh();
                        qMesh.vertices = RoadConnections_verts[index];
                        qMesh.triangles = RoadConnections_tris[index];
                        qMesh.normals = RoadConnections_normals[index];
                        qMesh.uv = RoadConnections_uv[index];
                        qMesh.RecalculateNormals();
                        RoadConnections_normals[index] = qMesh.normals;
                        tMesh_RoadConnections.Add(qMesh);
                    }
                }


                if ((tRoad.opt_bRoadCuts || tRoad.opt_bDynamicCuts) && RoadCuts.Count > 0)
                {
                    int[] tTris = null;
                    Vector3[] tNormals = null;
                    int cCount = cut_RoadVectors.Count;
                    for (int index = 0; index < cCount; index++)
                    {
                        tTris = cut_tris[index];
                        tNormals = cut_normals[index];
                        MeshBuffer = new Mesh();
                        tMesh_RoadCuts.Add(MeshSetup1_Helper(ref MeshBuffer, cut_RoadVectors[index].ToArray(), ref tTris, ref tNormals));
                        MeshBuffer = new Mesh();
                        tMesh_RoadCuts_world.Add(MeshSetup1_Helper(ref MeshBuffer, cut_RoadVectors[index].ToArray(), ref tTris, ref tNormals));
                        cut_normals[index] = tNormals;
                        tMeshSkip = true;
                    }
                }
                if (tRoad.opt_bShoulderCuts || tRoad.opt_bDynamicCuts)
                {
                    int[] tTris = null;
                    Vector3[] tNormals = null;
                    int rCount = cut_ShoulderR_Vectors.Count;
                    for (int index = 0; index < rCount; index++)
                    {
                        tTris = cut_tris_ShoulderR[index];
                        tNormals = cut_normals_ShoulderR[index];
                        MeshBuffer = new Mesh();
                        tMesh_SRCuts.Add(MeshSetup1_Helper(ref MeshBuffer, cut_ShoulderR_Vectors[index].ToArray(), ref tTris, ref tNormals));
                        MeshBuffer = new Mesh();
                        tMesh_SRCuts_world.Add(MeshSetup1_Helper(ref MeshBuffer, cut_ShoulderR_Vectors[index].ToArray(), ref tTris, ref tNormals));
                        cut_normals_ShoulderR[index] = tNormals;
                        tMesh_SRSkip = true;
                    }
                    if (rCount <= 0)
                    {
                        tMesh_SRSkip = false;
                    }
                    int lCount = cut_ShoulderL_Vectors.Count;
                    for (int index = 0; index < lCount; index++)
                    {
                        tTris = cut_tris_ShoulderL[index];
                        tNormals = cut_normals_ShoulderL[index];
                        MeshBuffer = new Mesh();
                        tMesh_SLCuts.Add(MeshSetup1_Helper(ref MeshBuffer, cut_ShoulderL_Vectors[index].ToArray(), ref tTris, ref tNormals));
                        MeshBuffer = new Mesh();
                        tMesh_SLCuts_world.Add(MeshSetup1_Helper(ref MeshBuffer, cut_ShoulderL_Vectors[index].ToArray(), ref tTris, ref tNormals));
                        cut_normals_ShoulderL[index] = tNormals;
                        tMesh_SLSkip = true;
                    }
                    if (lCount <= 0)
                    {
                        tMesh_SLSkip = false;
                    }
                }
            }

            if (bInterseOn)
            {
                MeshSetup1_IntersectionParts();
            }

            MeshBuffer = null;
        }


        #region "Intersection for MeshSetup1"
        private void MeshSetup1_IntersectionObjectsSetup()
        {
            int mCount = tRoad.GSDSpline.GetNodeCount();
            List<GSDRoadIntersection> tGSDRIs = new List<GSDRoadIntersection>();
            for (int index = 0; index < mCount; index++)
            {
                if (tRoad.GSDSpline.mNodes[index].bIsIntersection)
                {
                    if (!tGSDRIs.Contains(tRoad.GSDSpline.mNodes[index].GSDRI))
                    {
                        tGSDRIs.Add(tRoad.GSDSpline.mNodes[index].GSDRI);
                    }
                }
            }

            //Cleanups:
            foreach (GSDRoadIntersection GSDRI in tGSDRIs)
            {
                GSDIntersectionObjects.CleanupIntersectionObjects(GSDRI.transform.gameObject);
                if (GSDRI.iStopType == GSDRoadIntersection.iStopTypeEnum.StopSign_AllWay)
                {
                    GSDIntersectionObjects.CreateStopSignsAllWay(GSDRI.transform.gameObject, true);
                }
                else if (GSDRI.iStopType == GSDRoadIntersection.iStopTypeEnum.TrafficLight1)
                {
                    GSDIntersectionObjects.CreateTrafficLightBases(GSDRI.transform.gameObject, true);
                }
                else if (GSDRI.iStopType == GSDRoadIntersection.iStopTypeEnum.TrafficLight2)
                {

                }
                else if (GSDRI.iStopType == GSDRoadIntersection.iStopTypeEnum.None)
                {
                    //Do nothing.
                }
            }
        }


        private void MeshSetup1_IntersectionParts()
        {
            int mCount = tRoad.GSDSpline.GetNodeCount();
            bool bHasInter = false;
            for (int index = 0; index < mCount; index++)
            {
                if (tRoad.GSDSpline.mNodes[index].bIsIntersection)
                {
                    bHasInter = true;
                    break;
                }
            }
            if (!bHasInter)
            {
                return;
            }

            int vCount = -1;
            Mesh MeshBuffer = null;
            Vector3[] tNormals = null;
            int[] tTris = null;
            //Back lanes:
            vCount = iBLane0s.Count;
            for (int i = 0; i < vCount; i++)
            {
                tNormals = iBLane0s_normals[i];
                tTris = iBLane0s_tris[i];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iBLane0s[i], ref tTris, ref tNormals);
                tMesh_iBLanes0.Add(MeshBuffer);
            }
            vCount = iBLane1s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iBLane1s_normals[index];
                tTris = iBLane1s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iBLane1s[index], ref tTris, ref tNormals);
                tMesh_iBLanes1.Add(MeshBuffer);
            }
            vCount = iBLane2s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iBLane2s_normals[index];
                tTris = iBLane2s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iBLane2s[index], ref tTris, ref tNormals);
                tMesh_iBLanes2.Add(MeshBuffer);
            }
            vCount = iBLane3s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iBLane3s_normals[index];
                tTris = iBLane3s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iBLane3s[index], ref tTris, ref tNormals);
                tMesh_iBLanes3.Add(MeshBuffer);
            }
            //Front lanes:
            vCount = iFLane0s.Count;
            for (int i = 0; i < vCount; i++)
            {
                tNormals = iFLane0s_normals[i];
                tTris = iFLane0s_tris[i];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iFLane0s[i], ref tTris, ref tNormals);
                tMesh_iFLanes0.Add(MeshBuffer);
            }
            vCount = iFLane1s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iFLane1s_normals[index];
                tTris = iFLane1s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iFLane1s[index], ref tTris, ref tNormals);
                tMesh_iFLanes1.Add(MeshBuffer);
            }
            vCount = iFLane2s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iFLane2s_normals[index];
                tTris = iFLane2s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iFLane2s[index], ref tTris, ref tNormals);
                tMesh_iFLanes2.Add(MeshBuffer);
            }
            vCount = iFLane3s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iFLane3s_normals[index];
                tTris = iFLane3s_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iFLane3s[index], ref tTris, ref tNormals);
                tMesh_iFLanes3.Add(MeshBuffer);
            }
            //Main plates:
            vCount = iBMainPlates.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iBMainPlates_normals[index];
                tTris = iBMainPlates_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iBMainPlates[index], ref tTris, ref tNormals);
                tMesh_iBMainPlates.Add(MeshBuffer);
            }
            vCount = iFMainPlates.Count;
            for (int index = 0; index < vCount; index++)
            {
                tNormals = iFMainPlates_normals[index];
                tTris = iFMainPlates_tris[index];
                MeshBuffer = new Mesh();
                MeshBuffer = MeshSetup1_Helper(ref MeshBuffer, iFMainPlates[index], ref tTris, ref tNormals);
                tMesh_iFMainPlates.Add(MeshBuffer);
            }

            MeshBuffer = null;
        }
        #endregion


        private Mesh MeshSetup1_Helper(ref Mesh xMesh, Vector3[] verts, ref int[] tris, ref Vector3[] normals)
        {
            xMesh.vertices = verts;
            xMesh.triangles = tris;
            xMesh.normals = normals;
            xMesh.RecalculateNormals();
            normals = xMesh.normals;
            //			xMesh.hideFlags = HideFlags.DontSave;
            return xMesh;
        }
        #endregion


        #region "Mesh Setup2"
        public void MeshSetup2()
        {
            MeshSetup2_Do();
        }


        /// <summary>
        /// Assigns UV and tangents to meshes. If multithreading enabled, this occurs after the last threaded job since unity library can't be used in threads.
        /// </summary>
        private void MeshSetup2_Do()
        {
            Mesh MeshMainBuffer = null;
            Mesh MeshMarkerBuffer = null;

            if (bRoadOn)
            {
                //If road cuts is off, full size UVs:
                if ((!tRoad.opt_bRoadCuts && !tRoad.opt_bDynamicCuts) || (RoadCuts == null || RoadCuts.Count <= 0))
                {
                    if (tMesh != null)
                    {
                        tMesh = MeshSetup2_Helper(ref tMesh, uv, tangents, ref tRoad.MeshRoad, true);
                        SaveMesh(SaveMeshTypeEnum.Road, tMesh, tRoad, tRoad.MeshRoad.transform.name);

                        Vector3[] ooVerts = new Vector3[tMesh.vertexCount];
                        int[] ooTris = new int[tMesh.triangles.Length];
                        Vector3[] ooNormals = new Vector3[tMesh.normals.Length];
                        Vector2[] ooUV = new Vector2[uv2.Length];
                        Vector4[] ooTangents = new Vector4[tangents2.Length];

                        System.Array.Copy(tMesh.vertices, ooVerts, ooVerts.Length);
                        System.Array.Copy(tMesh.triangles, ooTris, ooTris.Length);
                        System.Array.Copy(tMesh.normals, ooNormals, ooNormals.Length);
                        System.Array.Copy(uv2, ooUV, ooUV.Length);
                        System.Array.Copy(tangents2, ooTangents, ooTangents.Length);

                        Mesh pMesh = new Mesh();
                        pMesh.vertices = ooVerts;
                        pMesh.triangles = ooTris;
                        pMesh.normals = ooNormals;
                        pMesh.uv = ooUV;
                        pMesh.tangents = ooTangents;

                        GameObject gObj = new GameObject("Pavement");
                        pMesh = MeshSetup2_Helper(ref pMesh, uv2, tangents2, ref gObj, false);
                        gObj.transform.parent = tRoad.MeshRoad.transform;   //Road markers stored on parent "MeshRoad" game object, with a "Pavement" child game object storing the asphalt.
                        SaveMesh(SaveMeshTypeEnum.Road, pMesh, tRoad, gObj.transform.name);
                    }
                }
                else
                {
                    //If road cuts, change it to one material (pavement) with world mapping
                    int cCount = cut_RoadVectors.Count;
                    //					Vector2[] tUV;
                    GameObject CreatedMainObj;
                    GameObject CreatedMarkerObj;
                    for (int i = 0; i < cCount; i++)
                    {
                        CreatedMainObj = null;
                        MeshMainBuffer = tMesh_RoadCuts_world[i];
                        if (MeshMainBuffer != null)
                        {
                            MeshSetup2_Helper_RoadCuts(i, ref MeshMainBuffer, cut_uv_world[i], cut_tangents_world[i], ref tRoad.MeshRoad, false, out CreatedMainObj);
                            SaveMesh(SaveMeshTypeEnum.RoadCut, MeshMainBuffer, tRoad, "RoadCut" + i.ToString());
                        }

                        CreatedMarkerObj = null;
                        MeshMarkerBuffer = tMesh_RoadCuts[i];
                        bool bHasMats = false;
                        if (MeshMarkerBuffer != null)
                        {
                            bHasMats = MeshSetup2_Helper_RoadCuts(i, ref MeshMarkerBuffer, cut_uv[i], cut_tangents[i], ref CreatedMainObj, true, out CreatedMarkerObj);
                            if (bHasMats)
                            {
                                SaveMesh(SaveMeshTypeEnum.RoadCut, MeshMarkerBuffer, tRoad, "RoadCutMarker" + i.ToString());
                            }
                            else
                            {
                                //Destroy if no marker materials:
                                Object.DestroyImmediate(CreatedMarkerObj);
                                Object.DestroyImmediate(MeshMarkerBuffer);
                            }
                        }
                    }

                    //Remove main mesh stuff if necessary:
                    if (tRoad.MeshRoad != null)
                    {
                        MeshCollider tMC = tRoad.MeshRoad.GetComponent<MeshCollider>();
                        MeshRenderer tMR = tRoad.MeshRoad.GetComponent<MeshRenderer>();
                        if (tMC != null)
                        {
                            Object.DestroyImmediate(tMC);
                        }
                        if (tMR != null)
                        {
                            Object.DestroyImmediate(tMR);
                        }
                    }
                    if (tMesh != null)
                    {
                        Object.DestroyImmediate(tMesh);
                    }
                }

                //Shoulders:
                if (tRoad.opt_bShouldersEnabled)
                {
                    if ((!tRoad.opt_bShoulderCuts && !tRoad.opt_bDynamicCuts) || (ShoulderCutsL == null || cut_ShoulderL_Vectors.Count <= 0))
                    {
                        //Right road shoulder:
                        if (tMesh_SR != null)
                        {
                            tMesh_SR = MeshSetup2_Helper(ref tMesh_SR, uv_SR, tangents_SR, ref tRoad.MeshShoR, false, true);
                            SaveMesh(SaveMeshTypeEnum.Shoulder, tMesh_SR, tRoad, tRoad.MeshShoR.transform.name);
                        }

                        //Left road shoulder:
                        if (tMesh_SL != null)
                        {
                            tMesh_SL = MeshSetup2_Helper(ref tMesh_SL, uv_SL, tangents_SL, ref tRoad.MeshShoL, false, true);
                            SaveMesh(SaveMeshTypeEnum.Shoulder, tMesh_SL, tRoad, tRoad.MeshShoL.transform.name);
                        }
                    }
                    else
                    {
                        GameObject CreatedMainObj;
                        GameObject CreatedMarkerObj;
                        int rCount = cut_ShoulderR_Vectors.Count;
                        for (int index = 0; index < rCount; index++)
                        {
                            bool bHasMats = false;
                            CreatedMainObj = null;
                            MeshMainBuffer = tMesh_SRCuts_world[index];
                            if (MeshMainBuffer != null)
                            {
                                MeshSetup2_Helper_CutsShoulder(index, ref MeshMainBuffer, cut_uv_SR_world[index], cut_tangents_SR_world[index], ref tRoad.MeshShoR, false, false, out CreatedMainObj);
                                SaveMesh(SaveMeshTypeEnum.SCut, MeshMainBuffer, tRoad, "SCutR" + index.ToString());
                            }

                            CreatedMarkerObj = null;
                            MeshMarkerBuffer = tMesh_SRCuts[index];
                            if (MeshMarkerBuffer != null)
                            {
                                bHasMats = MeshSetup2_Helper_CutsShoulder(index, ref MeshMarkerBuffer, cut_uv_SR[index], cut_tangents_SR[index], ref CreatedMainObj, false, true, out CreatedMarkerObj);
                                if (bHasMats)
                                {
                                    SaveMesh(SaveMeshTypeEnum.SCut, MeshMarkerBuffer, tRoad, "SCutRMarker" + index.ToString());
                                }
                                else
                                {
                                    //Destroy if no marker materials:
                                    Object.DestroyImmediate(CreatedMarkerObj);
                                    Object.DestroyImmediate(MeshMarkerBuffer);
                                }
                            }
                        }

                        int lCount = cut_ShoulderL_Vectors.Count;
                        for (int index = 0; index < lCount; index++)
                        {
                            bool bHasMats = false;
                            CreatedMainObj = null;
                            MeshMainBuffer = tMesh_SLCuts_world[index];
                            if (MeshMainBuffer != null)
                            {
                                MeshSetup2_Helper_CutsShoulder(index, ref MeshMainBuffer, cut_uv_SL_world[index], cut_tangents_SL_world[index], ref tRoad.MeshShoL, true, false, out CreatedMainObj);
                                SaveMesh(SaveMeshTypeEnum.SCut, MeshMainBuffer, tRoad, "SCutL" + index.ToString());
                            }


                            CreatedMarkerObj = null;
                            MeshMarkerBuffer = tMesh_SLCuts[index];
                            if (MeshMarkerBuffer != null)
                            {
                                bHasMats = MeshSetup2_Helper_CutsShoulder(index, ref MeshMarkerBuffer, cut_uv_SL[index], cut_tangents_SL[index], ref CreatedMainObj, true, true, out CreatedMarkerObj);
                                if (bHasMats)
                                {
                                    SaveMesh(SaveMeshTypeEnum.SCut, MeshMarkerBuffer, tRoad, "SCutLMarker" + index.ToString());
                                }
                                else
                                {
                                    //Destroy if no marker materials:
                                    Object.DestroyImmediate(CreatedMarkerObj);
                                    Object.DestroyImmediate(MeshMarkerBuffer);
                                }
                            }
                        }

                        if (tRoad.opt_bUseMeshColliders)
                        {
                            //						MeshSetup2_Intersections_FixNormals();	
                        }

                        //Remove main mesh stuff if necessary:
                        if (tMesh_SR != null)
                        {
                            Object.DestroyImmediate(tMesh_SR);
                        }
                        if (tMesh_SL != null)
                        {
                            Object.DestroyImmediate(tMesh_SL);
                        }

                        if (tRoad.MeshShoR != null)
                        {
                            MeshCollider tMC = tRoad.MeshShoR.GetComponent<MeshCollider>();
                            MeshRenderer tMR = tRoad.MeshShoR.GetComponent<MeshRenderer>();
                            if (tMC != null)
                            {
                                Object.DestroyImmediate(tMC);
                            }
                            if (tMR != null)
                            {
                                Object.DestroyImmediate(tMR);
                            }
                        }
                        if (tRoad.MeshShoL != null)
                        {
                            MeshCollider tMC = tRoad.MeshShoL.GetComponent<MeshCollider>();
                            MeshRenderer tMR = tRoad.MeshShoL.GetComponent<MeshRenderer>();
                            if (tMC != null)
                            {
                                Object.DestroyImmediate(tMC);
                            }
                            if (tMR != null)
                            {
                                Object.DestroyImmediate(tMR);
                            }
                        }
                    }
                }
                else
                {
                    //Remove main mesh stuff if necessary:
                    if (tMesh_SR != null)
                    {
                        Object.DestroyImmediate(tMesh_SR);
                    }
                    if (tMesh_SL != null)
                    {
                        Object.DestroyImmediate(tMesh_SL);
                    }

                    if (tRoad.MeshShoR != null)
                    {
                        MeshCollider tMC = tRoad.MeshShoR.GetComponent<MeshCollider>();
                        MeshRenderer tMR = tRoad.MeshShoR.GetComponent<MeshRenderer>();
                        if (tMC != null)
                        {
                            Object.DestroyImmediate(tMC);
                        }
                        if (tMR != null)
                        {
                            Object.DestroyImmediate(tMR);
                        }
                    }
                    if (tRoad.MeshShoL != null)
                    {
                        MeshCollider tMC = tRoad.MeshShoL.GetComponent<MeshCollider>();
                        MeshRenderer tMR = tRoad.MeshShoL.GetComponent<MeshRenderer>();
                        if (tMC != null)
                        {
                            Object.DestroyImmediate(tMC);
                        }
                        if (tMR != null)
                        {
                            Object.DestroyImmediate(tMR);
                        }
                    }

                    Mesh tBuffer = null;
                    int xCount = tMesh_SRCuts_world.Count;
                    for (int index = 0; index < xCount; index++)
                    {
                        tBuffer = tMesh_SRCuts_world[index];
                        Object.DestroyImmediate(tBuffer);
                        tMesh_SRCuts_world[index] = null;
                    }
                    xCount = tMesh_SRCuts.Count;
                    for (int index = 0; index < xCount; index++)
                    {
                        tBuffer = tMesh_SRCuts[index];
                        Object.DestroyImmediate(tBuffer);
                        tMesh_SRCuts[index] = null;
                    }
                    xCount = tMesh_SLCuts_world.Count;
                    for (int index = 0; index < xCount; index++)
                    {
                        tBuffer = tMesh_SLCuts_world[index];
                        Object.DestroyImmediate(tBuffer);
                        tMesh_SLCuts_world[index] = null;
                    }
                    xCount = tMesh_SLCuts.Count;
                    for (int index = 0; index < xCount; index++)
                    {
                        tBuffer = tMesh_SLCuts[index];
                        Object.DestroyImmediate(tBuffer);
                        tMesh_SLCuts[index] = null;
                    }

                    if (tRoad.MeshShoR != null)
                    {
                        Object.DestroyImmediate(tRoad.MeshShoR);
                    }

                    if (tRoad.MeshShoL != null)
                    {
                        Object.DestroyImmediate(tRoad.MeshShoL);
                    }
                }


                for (int index = 0; index < RoadConnections_tangents.Count; index++)
                {
                    tMesh_RoadConnections[index].tangents = RoadConnections_tangents[index];
                    GameObject tObj = new GameObject("RoadConnectionMarker");
                    MeshFilter MF = tObj.AddComponent<MeshFilter>();
                    MeshRenderer MR = tObj.AddComponent<MeshRenderer>();
                    float fDist = Vector3.Distance(RoadConnections_verts[index][2], RoadConnections_verts[index][3]);
                    fDist = Mathf.Round(fDist);
                    if (tRoad.opt_Lanes == 2)
                    {
                        if (fDist == Mathf.Round(tRoad.RoadWidth() * 2f))
                        {
                            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDRoadConn-4L.mat", MR);
                        }
                        else if (fDist == Mathf.Round(tRoad.RoadWidth() * 3f))
                        {
                            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDRoadConn-6L-2L.mat", MR);
                        }
                    }
                    else if (tRoad.opt_Lanes == 4)
                    {
                        if (fDist == Mathf.Round(tRoad.RoadWidth() * 1.5f))
                        {
                            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDRoadConn-6L-4L.mat", MR);
                        }
                    }
                    MF.sharedMesh = tMesh_RoadConnections[index];
                    tObj.transform.parent = tRoad.MeshRoad.transform;

                    Mesh vMesh = new Mesh();
                    vMesh.vertices = RoadConnections_verts[index];
                    vMesh.triangles = RoadConnections_tris[index];
                    vMesh.normals = RoadConnections_normals[index];
                    Vector2[] vUV = new Vector2[4];
                    vUV[0] = new Vector2(RoadConnections_verts[index][0].x / 5f, RoadConnections_verts[index][0].z / 5f);
                    vUV[1] = new Vector2(RoadConnections_verts[index][1].x / 5f, RoadConnections_verts[index][1].z / 5f);
                    vUV[2] = new Vector2(RoadConnections_verts[index][2].x / 5f, RoadConnections_verts[index][2].z / 5f);
                    vUV[3] = new Vector2(RoadConnections_verts[index][3].x / 5f, RoadConnections_verts[index][3].z / 5f);
                    vMesh.uv = vUV;
                    vMesh.RecalculateNormals();
                    RoadConnections_normals[index] = vMesh.normals;
                    vMesh.tangents = GSDRootUtil.ProcessTangents(vMesh.triangles, vMesh.normals, vMesh.uv, vMesh.vertices);

                    tObj = new GameObject("RoadConnectionBase");
                    MF = tObj.AddComponent<MeshFilter>();
                    MR = tObj.AddComponent<MeshRenderer>();
                    MeshCollider MC = tObj.AddComponent<MeshCollider>();
                    MF.sharedMesh = vMesh;
                    MC.sharedMesh = MF.sharedMesh;
                    GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDRoad1.mat", MR);
                    tObj.transform.parent = tRoad.MeshRoad.transform;

                    SaveMesh(SaveMeshTypeEnum.RoadConn, vMesh, tRoad, "RoadConn" + index.ToString());
                }
            }

            if (bInterseOn)
            {
                MeshSetup2_Intersections();
            }

            if (tRoad.MeshiLanes != null)
            {
                Object.DestroyImmediate(tRoad.MeshiLanes);
            }
            if (tRoad.MeshiLanes0 != null)
            {
                Object.DestroyImmediate(tRoad.MeshiLanes0);
            }
            if (tRoad.MeshiLanes1 != null)
            {
                Object.DestroyImmediate(tRoad.MeshiLanes1);
            }
            if (tRoad.MeshiLanes2 != null)
            {
                Object.DestroyImmediate(tRoad.MeshiLanes2);
            }
            if (tRoad.MeshiLanes3 != null)
            {
                Object.DestroyImmediate(tRoad.MeshiLanes3);
            }
            if (tRoad.MeshiMainPlates != null)
            {
                Object.DestroyImmediate(tRoad.MeshiMainPlates);
            }
            if (tRoad.MeshiMarkerPlates != null)
            {
                Object.DestroyImmediate(tRoad.MeshiMarkerPlates);
            }

            //Updates the road and shoulder cut materials if necessary. Note: Cycling through all nodes in case the road cuts and shoulder cut numbers don't match.
            if (tRoad.opt_bRoadCuts || tRoad.opt_bShoulderCuts || tRoad.opt_bDynamicCuts)
            {
                int mCount = tRoad.GSDSpline.GetNodeCount();
                for (int index = 0; index < mCount; index++)
                {
                    tRoad.GSDSpline.mNodes[index].UpdateCuts();
                }
            }
        }


        #region "MeshSetup2 - Intersections"
        //		private void MeshSetup2_Intersections_FixNormals(){
        //			int mCount = tRoad.GSDSpline.GetNodeCount();
        //			GSDSplineN tNode = null;
        //			GSDRoadIntersection GSDRI = null;
        //			float MaxDist = 0f;
        //			float[] tDists = new float[2];
        //			Collider[] tColliders = null;
        //			List<GameObject> tCuts = null;
        //
        //			for(int h=0;h<mCount;h++){
        //				tNode=tRoad.GSDSpline.mNodes[h];
        //				if(tNode.bIsIntersection){
        //					GSDRI = tNode.GSDRI;
        //					
        //					
        //					
        //
        //					tColliders = Physics.OverlapSphere(GSDRI.CornerRR_Outer,tRoad.opt_ShoulderWidth*1.25f);
        //					tCuts = new List<GameObject>();
        //					foreach(Collider tCollider in tColliders){
        //						if(tCollider.transform.name.Contains("cut")){
        //							tCuts.Add(tCollider.transform.gameObject);
        //						}
        //					}
        //					
        //					
        //					
        //					foreach(GameObject tObj in tCuts){
        //						MeshFilter MF1 = tCuts[0].GetComponent<MeshFilter>();
        //						if(MF1 == null){ continue; }
        //						Mesh zMesh1 = MF1.sharedMesh;
        //						Vector3[] tVerts1 = zMesh1.vertices;
        //						Vector3[] tNormals1 = zMesh1.normals;
        //						int MVL1 = tVerts1.Length;
        //						for(int i=0;i<MVL1;i++){
        //							if(tVerts1[i] == GSDRI.CornerRR){
        //								tNormals1[i] = Vector3.up;
        //							}else if(tVerts1[i] == GSDRI.CornerRR_Outer){
        //								tNormals1[i] = Vector3.up;
        //							}
        //						}
        //					}
        //
        //					
        //				}
        //			}
        //		}

        private void MeshSetup2_Intersections()
        {
            int mCount = tRoad.GSDSpline.GetNodeCount();
            bool bHasInter = false;
            for (int index = 0; index < mCount; index++)
            {
                if (tRoad.GSDSpline.mNodes[index].bIsIntersection)
                {
                    bHasInter = true;
                    break;
                }
            }
            if (!bHasInter)
            {
                return;
            }


            int vCount = -1;
            Mesh xMesh = null;
            Vector2[] tUV = null;
            Vector4[] tTangents = null;
            MeshFilter MF = null;
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane0 = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane1 = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane2 = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane3 = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_MainPlate = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_MainPlateM = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            HashSet<GSDRoadIntersection> UniqueGSDRI = new HashSet<GSDRoadIntersection>();

            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane1_Disabled = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane2_Disabled = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane2_DisabledActive = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane2_DisabledActiveR = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane3_Disabled = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();
            Dictionary<GSDRoadIntersection, List<MeshFilter>> tCombineDict_Lane1_DisabledActive = new Dictionary<GSDRoadIntersection, List<MeshFilter>>();

            vCount = iBLane0s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tUV = iBLane0s_uv[index];
                tTangents = iBLane0s_tangents[index];
                xMesh = tMesh_iBLanes0[index];
                MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes0, "Lane0B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteLYellowR.mat");
                if (!tCombineDict_Lane0.ContainsKey(iBLane0s_tID[index]))
                {
                    tCombineDict_Lane0.Add(iBLane0s_tID[index], new List<MeshFilter>());
                }
                tCombineDict_Lane0[iBLane0s_tID[index]].Add(MF);
            }
            vCount = iBLane1s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iBLane1s_tID[index].Node1 == iBLane1s_nID[index]);
                if (!bPrimaryNode && iBLane1s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && (iBLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.TurnLane || iBLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes) && !iBLane1s_tID[index].bNode2B_LeftTurnLane)
                {
                    tUV = iBLane1s_uv[index];
                    tTangents = iBLane1s_tangents[index];
                    xMesh = tMesh_iBLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "LaneD1B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabled.mat");
                    if (!tCombineDict_Lane1_Disabled.ContainsKey(iBLane1s_tID[index]))
                    {
                        tCombineDict_Lane1_Disabled.Add(iBLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1_Disabled[iBLane1s_tID[index]].Add(MF);
                }
                else if (bPrimaryNode && iBLane1s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iBLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
                {
                    tUV = iBLane1s_uv[index];
                    tTangents = iBLane1s_tangents[index];
                    xMesh = tMesh_iBLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "LaneDA1B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuter.mat");
                    if (!tCombineDict_Lane1_DisabledActive.ContainsKey(iBLane1s_tID[index]))
                    {
                        tCombineDict_Lane1_DisabledActive.Add(iBLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1_DisabledActive[iBLane1s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iBLane1s_uv[index];
                    tTangents = iBLane1s_tangents[index];
                    xMesh = tMesh_iBLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "Lane1B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterYellowLWhiteR.mat");
                    if (!tCombineDict_Lane1.ContainsKey(iBLane1s_tID[index]))
                    {
                        tCombineDict_Lane1.Add(iBLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1[iBLane1s_tID[index]].Add(MF);
                }
            }
            vCount = iBLane2s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iBLane2s_tID[index].Node1 == iBLane2s_nID[index]);
                if (!bPrimaryNode && iBLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && (iBLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.TurnLane || iBLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes) && !iBLane2s_tID[index].bNode2B_LeftTurnLane)
                {
                    tUV = iBLane2s_uv[index];
                    tTangents = iBLane2s_tangents[index];
                    xMesh = tMesh_iBLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneDA2B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuter.mat");
                    if (!tCombineDict_Lane2_DisabledActive.ContainsKey(iBLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_DisabledActive.Add(iBLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_DisabledActive[iBLane2s_tID[index]].Add(MF);
                }
                else if (!bPrimaryNode && iBLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iBLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes && !iBLane2s_tID[index].bNode2B_RightTurnLane)
                {
                    tUV = iBLane2s_uv[index];
                    tTangents = iBLane2s_tangents[index];
                    xMesh = tMesh_iBLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneDA2B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuterR.mat");
                    if (!tCombineDict_Lane2_DisabledActiveR.ContainsKey(iBLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_DisabledActiveR.Add(iBLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_DisabledActiveR[iBLane2s_tID[index]].Add(MF);
                }
                else if (bPrimaryNode && iBLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iBLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
                {
                    tUV = iBLane2s_uv[index];
                    tTangents = iBLane2s_tangents[index];
                    xMesh = tMesh_iBLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneD2B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabled.mat");
                    if (!tCombineDict_Lane2_Disabled.ContainsKey(iBLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_Disabled.Add(iBLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_Disabled[iBLane2s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iBLane2s_uv[index];
                    tTangents = iBLane2s_tangents[index];
                    xMesh = tMesh_iBLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "Lane2B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteR.mat");
                    if (!tCombineDict_Lane2.ContainsKey(iBLane2s_tID[index]))
                    {
                        tCombineDict_Lane2.Add(iBLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2[iBLane2s_tID[index]].Add(MF);
                }
            }
            vCount = iBLane3s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iBLane3s_tID[index].Node1 == iBLane3s_nID[index]);
                if (!bPrimaryNode && iBLane3s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iBLane3s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes && !iBLane3s_tID[index].bNode2B_RightTurnLane)
                {
                    tUV = iBLane3s_uv[index];
                    tTangents = iBLane3s_tangents[index];
                    xMesh = tMesh_iBLanes3[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes3, "LaneD3B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabled.mat");
                    if (!tCombineDict_Lane3_Disabled.ContainsKey(iBLane3s_tID[index]))
                    {
                        tCombineDict_Lane3_Disabled.Add(iBLane3s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane3_Disabled[iBLane3s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iBLane3s_uv[index];
                    tTangents = iBLane3s_tangents[index];
                    xMesh = tMesh_iBLanes3[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes3, "Lane3B", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteR.mat");
                    if (!tCombineDict_Lane3.ContainsKey(iBLane3s_tID[index]))
                    {
                        tCombineDict_Lane3.Add(iBLane3s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane3[iBLane3s_tID[index]].Add(MF);
                }
            }

            //Front lanes:
            vCount = iFLane0s.Count;
            for (int index = 0; index < vCount; index++)
            {
                tUV = iFLane0s_uv[index];
                tTangents = iFLane0s_tangents[index];
                xMesh = tMesh_iFLanes0[index];
                MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes0, "Lane0F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteLYellowR.mat");
                if (!tCombineDict_Lane0.ContainsKey(iFLane0s_tID[index]))
                {
                    tCombineDict_Lane0.Add(iFLane0s_tID[index], new List<MeshFilter>());
                }
                tCombineDict_Lane0[iFLane0s_tID[index]].Add(MF);
            }
            vCount = iFLane1s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iFLane1s_tID[index].Node1 == iFLane1s_nID[index]);
                if (!bPrimaryNode && iFLane1s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && (iFLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes || iFLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.TurnLane) && !iFLane1s_tID[index].bNode2F_LeftTurnLane)
                {
                    tUV = iFLane1s_uv[index];
                    tTangents = iFLane1s_tangents[index];
                    xMesh = tMesh_iFLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "LaneD1F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabled.mat");
                    if (!tCombineDict_Lane1_Disabled.ContainsKey(iFLane1s_tID[index]))
                    {
                        tCombineDict_Lane1_Disabled.Add(iFLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1_Disabled[iFLane1s_tID[index]].Add(MF);
                }
                else if (bPrimaryNode && iFLane1s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iFLane1s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
                {
                    tUV = iFLane1s_uv[index];
                    tTangents = iFLane1s_tangents[index];
                    xMesh = tMesh_iFLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "LaneDAR1F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuterR.mat");
                    if (!tCombineDict_Lane1_DisabledActive.ContainsKey(iFLane1s_tID[index]))
                    {
                        tCombineDict_Lane1_DisabledActive.Add(iFLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1_DisabledActive[iFLane1s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iFLane1s_uv[index];
                    tTangents = iFLane1s_tangents[index];
                    xMesh = tMesh_iFLanes1[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes1, "Lane1F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterYellowLWhiteR.mat");
                    if (!tCombineDict_Lane1.ContainsKey(iFLane1s_tID[index]))
                    {
                        tCombineDict_Lane1.Add(iFLane1s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane1[iFLane1s_tID[index]].Add(MF);
                }
            }
            vCount = iFLane2s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iFLane2s_tID[index].Node1 == iFLane2s_nID[index]);
                if (!bPrimaryNode && iFLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && (iFLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes || iFLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.TurnLane) && !iFLane2s_tID[index].bNode2F_LeftTurnLane)
                {
                    tUV = iFLane2s_uv[index];
                    tTangents = iFLane2s_tangents[index];
                    xMesh = tMesh_iFLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneDA2F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuter.mat");
                    if (!tCombineDict_Lane2_DisabledActive.ContainsKey(iFLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_DisabledActive.Add(iFLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_DisabledActive[iFLane2s_tID[index]].Add(MF);
                }
                else if (!bPrimaryNode && iFLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iFLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes && !iFLane2s_tID[index].bNode2F_RightTurnLane)
                {
                    tUV = iFLane2s_uv[index];
                    tTangents = iFLane2s_tangents[index];
                    xMesh = tMesh_iFLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneDAR2F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabledOuterR.mat");
                    if (!tCombineDict_Lane2_DisabledActiveR.ContainsKey(iFLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_DisabledActiveR.Add(iFLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_DisabledActiveR[iFLane2s_tID[index]].Add(MF);
                }
                else if (bPrimaryNode && iFLane2s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iFLane2s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
                {
                    tUV = iFLane2s_uv[index];
                    tTangents = iFLane2s_tangents[index];
                    xMesh = tMesh_iFLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "LaneD2F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterLaneDisabled.mat");
                    if (!tCombineDict_Lane2_Disabled.ContainsKey(iFLane2s_tID[index]))
                    {
                        tCombineDict_Lane2_Disabled.Add(iFLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2_Disabled[iFLane2s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iFLane2s_uv[index];
                    tTangents = iFLane2s_tangents[index];
                    xMesh = tMesh_iFLanes2[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes2, "Lane2F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteR.mat");
                    if (!tCombineDict_Lane2.ContainsKey(iFLane2s_tID[index]))
                    {
                        tCombineDict_Lane2.Add(iFLane2s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane2[iFLane2s_tID[index]].Add(MF);
                }
            }
            vCount = iFLane3s.Count;
            for (int index = 0; index < vCount; index++)
            {
                bool bPrimaryNode = (iFLane3s_tID[index].Node1 == iFLane3s_nID[index]);
                if (!bPrimaryNode && iFLane3s_tID[index].iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay && iFLane3s_tID[index].rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes && !iFLane3s_tID[index].bNode2F_RightTurnLane)
                {
                    tUV = iFLane3s_uv[index];
                    tTangents = iFLane3s_tangents[index];
                    xMesh = tMesh_iFLanes3[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes3, "LaneD3F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteR.mat");
                    if (!tCombineDict_Lane3_Disabled.ContainsKey(iFLane3s_tID[index]))
                    {
                        tCombineDict_Lane3_Disabled.Add(iFLane3s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane3_Disabled[iFLane3s_tID[index]].Add(MF);
                }
                else
                {
                    tUV = iFLane3s_uv[index];
                    tTangents = iFLane3s_tangents[index];
                    xMesh = tMesh_iFLanes3[index];
                    MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiLanes3, "Lane3F", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Markers/GSDInterWhiteR.mat");
                    if (!tCombineDict_Lane3.ContainsKey(iFLane3s_tID[index]))
                    {
                        tCombineDict_Lane3.Add(iFLane3s_tID[index], new List<MeshFilter>());
                    }
                    tCombineDict_Lane3[iFLane3s_tID[index]].Add(MF);
                }
            }

            //Main plates:
            vCount = iBMainPlates.Count;
            for (int index = 0; index < vCount; index++)
            {
                tUV = iBMainPlates_uv[index];
                tTangents = iBMainPlates_tangents[index];
                xMesh = tMesh_iBMainPlates[index];
                MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiMainPlates, "MainPlateB", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDRoad1.mat", false);
                if (!tCombineDict_MainPlate.ContainsKey(iBMainPlates_tID[index]))
                {
                    tCombineDict_MainPlate.Add(iBMainPlates_tID[index], new List<MeshFilter>());
                }
                tCombineDict_MainPlate[iBMainPlates_tID[index]].Add(MF);

                Mesh fMesh = new Mesh();
                fMesh.vertices = iBMainPlates[index];
                fMesh.triangles = iBMainPlates_tris[index];
                fMesh.normals = iBMainPlates_normals[index];
                tUV = iBMainPlates_uv2[index];
                tTangents = iBMainPlates_tangents2[index];
                MF = MeshSetup2_Intersection_Helper(ref fMesh, ref tUV, ref tTangents, ref tRoad.MeshiMainPlates, "MainPlateBM", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDInterMainPlate1.mat");
                if (!tCombineDict_MainPlateM.ContainsKey(iBMainPlates_tID[index]))
                {
                    tCombineDict_MainPlateM.Add(iBMainPlates_tID[index], new List<MeshFilter>());
                }
                tCombineDict_MainPlateM[iBMainPlates_tID[index]].Add(MF);
            }
            vCount = iFMainPlates.Count;
            for (int index = 0; index < vCount; index++)
            {
                tUV = iFMainPlates_uv[index];
                tTangents = iFMainPlates_tangents[index];
                xMesh = tMesh_iFMainPlates[index];
                MF = MeshSetup2_Intersection_Helper(ref xMesh, ref tUV, ref tTangents, ref tRoad.MeshiMainPlates, "MainPlateFM", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDRoad1.mat", false);

                if (!tCombineDict_MainPlate.ContainsKey(iFMainPlates_tID[index]))
                {
                    tCombineDict_MainPlate.Add(iFMainPlates_tID[index], new List<MeshFilter>());
                }
                tCombineDict_MainPlate[iFMainPlates_tID[index]].Add(MF);

                Mesh tMesh = new Mesh();
                tMesh.vertices = iFMainPlates[index];
                tMesh.triangles = iFMainPlates_tris[index];
                tMesh.normals = iFMainPlates_normals[index];
                tUV = iFMainPlates_uv2[index];
                tTangents = iFMainPlates_tangents2[index];
                MF = MeshSetup2_Intersection_Helper(ref tMesh, ref tUV, ref tTangents, ref tRoad.MeshiMainPlates, "MainPlateFM", GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDInterMainPlate1.mat");
                if (!tCombineDict_MainPlateM.ContainsKey(iFMainPlates_tID[index]))
                {
                    tCombineDict_MainPlateM.Add(iFMainPlates_tID[index], new List<MeshFilter>());
                }
                tCombineDict_MainPlateM[iFMainPlates_tID[index]].Add(MF);
            }

            vCount = tRoad.GSDSpline.GetNodeCount();
            GSDSplineN tNode = null;
            for (int index = 0; index < vCount; index++)
            {
                tNode = tRoad.GSDSpline.mNodes[index];
                if (tNode.bIsIntersection && tNode.GSDRI != null && tNode.GSDRI.Node1 == tNode)
                {
                    //Create center plate
                    Vector3[] xVerts = new Vector3[4];
                    xVerts[0] = tNode.GSDRI.CornerLR;
                    xVerts[1] = tNode.GSDRI.CornerRR;
                    xVerts[2] = tNode.GSDRI.CornerLL;
                    xVerts[3] = tNode.GSDRI.CornerRL;


                    int[] xTris = new int[6];
                    xTris[0] = 0;
                    xTris[1] = 2;
                    xTris[2] = 1;
                    xTris[3] = 2;
                    xTris[4] = 3;
                    xTris[5] = 1;

                    Vector2[] xUV = new Vector2[4];
                    xUV[0] = new Vector2(xVerts[0].x / 5f, xVerts[0].z / 5f);
                    xUV[1] = new Vector2(xVerts[1].x / 5f, xVerts[1].z / 5f);
                    xUV[2] = new Vector2(xVerts[2].x / 5f, xVerts[2].z / 5f);
                    xUV[3] = new Vector2(xVerts[3].x / 5f, xVerts[3].z / 5f);

                    Vector2[] xUV2 = new Vector2[4];
                    xUV2[0] = new Vector2(0f, 0f);
                    xUV2[1] = new Vector2(1f, 0f);
                    xUV2[2] = new Vector2(0f, 1f);
                    xUV2[3] = new Vector2(1f, 1f);

                    Mesh vMesh = new Mesh();
                    vMesh.vertices = xVerts;
                    vMesh.triangles = xTris;
                    vMesh.normals = new Vector3[4];
                    vMesh.uv = xUV;
                    vMesh.RecalculateBounds();
                    vMesh.RecalculateNormals();
                    vMesh.tangents = GSDRootUtil.ProcessTangents(xTris, vMesh.normals, xUV, xVerts);
                    if (tRoad.opt_bIsLightmapped)
                    {
                        //UnityEditor.Unwrapping.GenerateSecondaryUVSet(vMesh);
                    }

                    int cCount = tNode.GSDRI.transform.childCount;
                    List<GameObject> GOToDelete = new List<GameObject>();
                    for (int j = 0; j < cCount; j++)
                    {
                        if (tNode.GSDRI.transform.GetChild(j).name.ToLower() == "tcenter")
                        {
                            GOToDelete.Add(tNode.GSDRI.transform.GetChild(j).gameObject);
                        }
                        if (tNode.GSDRI.transform.GetChild(j).name.ToLower() == "markcenter")
                        {
                            GOToDelete.Add(tNode.GSDRI.transform.GetChild(j).gameObject);
                        }
                    }
                    for (int j = GOToDelete.Count - 1; j >= 0; j--)
                    {
                        Object.DestroyImmediate(GOToDelete[j]);
                    }

                    GameObject tCenter = new GameObject("tCenter");
                    MF = tCenter.AddComponent<MeshFilter>();
                    MF.sharedMesh = vMesh;
                    tCenter.transform.parent = tNode.GSDRI.transform;
                    if (tRoad.opt_bIsLightmapped)
                    {
                        #if UNITY_2019_2_OR_NEWER
                        UnityEditor.GameObjectUtility.SetStaticEditorFlags(tCenter, UnityEditor.StaticEditorFlags.ContributeGI);
                        #else
                        UnityEditor.GameObjectUtility.SetStaticEditorFlags(tCenter, UnityEditor.StaticEditorFlags.LightmapStatic);
                        #endif
                    }
                    if (tRoad.opt_bIsStatic)
                    {
                        tCenter.isStatic = true;
                    }



                    Mesh mMesh = new Mesh();
                    Vector3[] bVerts = new Vector3[4];
                    mMesh.vertices = xVerts;
                    mMesh.triangles = xTris;
                    mMesh.normals = new Vector3[4];
                    mMesh.uv = xUV2;
                    mMesh.RecalculateBounds();
                    mMesh.RecalculateNormals();
                    mMesh.tangents = GSDRootUtil.ProcessTangents(xTris, vMesh.normals, xUV, xVerts);


                    GameObject tMarker = new GameObject("CenterMarkers");
                    //tMarker.transform.localPosition = default(Vector3);
                    MF = tMarker.AddComponent<MeshFilter>();
                    MF.sharedMesh = mMesh;
                    MeshRenderer MR = tMarker.AddComponent<MeshRenderer>();
                    MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
                    //					if(tNode.GSDRI.MarkerCenter != null){
                    ////						MR.material = tNode.GSDRI.MarkerCenter;
                    //					}
                    tMarker.transform.parent = tNode.GSDRI.transform;
                    if (tRoad.opt_bIsLightmapped)
                    {
                        #if UNITY_2019_2_OR_NEWER
                        UnityEditor.GameObjectUtility.SetStaticEditorFlags(tMarker, UnityEditor.StaticEditorFlags.ContributeGI);
                        #else
                        UnityEditor.GameObjectUtility.SetStaticEditorFlags(tMarker, UnityEditor.StaticEditorFlags.LightmapStatic);
                        #endif
                    }
                    if (tRoad.opt_bIsStatic)
                    {
                        tMarker.isStatic = true;
                    }

                    bVerts = MF.sharedMesh.vertices;
                    for (int j = 0; j < 4; j++)
                    {
                        bVerts[j].y = tNode.GSDRI.SignHeight;
                    }


                    int zCount = bVerts.Length;
                    for (int z = 0; z < zCount; z++)
                    {
                        bVerts[z] -= tNode.transform.position;
                    }

                    MF.sharedMesh.vertices = bVerts;



                    MR.transform.position = tNode.GSDRI.transform.position;

                    mMesh.RecalculateBounds();
                    if (tRoad.opt_bIsLightmapped)
                    {
                        //UnityEditor.Unwrapping.GenerateSecondaryUVSet(mMesh);
                    }
                    SaveMesh(SaveMeshTypeEnum.Intersection, MF.sharedMesh, tRoad, tNode.GSDRI.transform.name + "-" + "CenterMarkers");
                }
            }

            //			List<Mesh> MeshToDelete = new List<Mesh>();

            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane0)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "Lane0");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane1)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "Lane1");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane2)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "Lane2");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane3)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "Lane3");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_MainPlate)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "TiledExt", true);
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_MainPlateM)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "StretchExt");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane1_Disabled)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneD1");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane3_Disabled)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneD3");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane2_DisabledActive)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneDA2");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane2_DisabledActiveR)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneDAR2");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane2_Disabled)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneD2");
            }
            foreach (KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP in tCombineDict_Lane1_DisabledActive)
            {
                if (!UniqueGSDRI.Contains(KVP.Key))
                {
                    UniqueGSDRI.Add(KVP.Key);
                }
                MeshSetup2_CombineIntersections(KVP, KVP.Key.transform.name + "-" + "LaneDA1");
            }

            foreach (GSDRoadIntersection GSDRI in UniqueGSDRI)
            {
                GSDRI.UpdateMaterials();
            }

        }


        private void MeshSetup2_CombineIntersections(KeyValuePair<GSDRoadIntersection, List<MeshFilter>> KVP, string tName, bool bMainPlates = false)
        {
            int vCount = KVP.Value.Count;
            if (vCount < 1)
            {
                return;
            }
            tName = tRoad.name + "-" + tName;
            GameObject tCenter = null;
            int cCount = KVP.Key.transform.childCount;
            List<GameObject> GOToDelete = new List<GameObject>();
            for (int index = 0; index < cCount; index++)
            {
                if (KVP.Key.transform.GetChild(index).name.ToLower() == tName.ToLower())
                {
                    GOToDelete.Add(KVP.Key.transform.GetChild(index).gameObject);
                }
                if (bMainPlates && KVP.Key.transform.GetChild(index).name.ToLower() == "tcenter")
                {
                    tCenter = KVP.Key.transform.GetChild(index).gameObject;
                }
            }
            for (int index = GOToDelete.Count - 1; index >= 0; index--)
            {
                Object.DestroyImmediate(GOToDelete[index]);
            }

            int CombineCount = vCount;
            if (tCenter != null)
            {
                CombineCount += 1;
            }
            CombineInstance[] combine = new CombineInstance[CombineCount];
            for (int index = 0; index < vCount; index++)
            {
                combine[index].mesh = KVP.Value[index].sharedMesh;
                combine[index].transform = KVP.Value[index].transform.localToWorldMatrix;
            }

            int SpecialVertCount = 0;
            if (tCenter != null)
            {
                for (int index = 0; index < (CombineCount - 1); index++)
                {
                    SpecialVertCount += combine[index].mesh.vertexCount;
                }
                MeshFilter tMF = tCenter.GetComponent<MeshFilter>();
                Vector3[] xVerts = tMF.sharedMesh.vertices;
                float xHeight = combine[0].mesh.vertices[combine[0].mesh.vertexCount - 1].y;
                for (int index = 0; index < xVerts.Length; index++)
                {
                    xVerts[index].y = xHeight;
                }
                tMF.sharedMesh.vertices = xVerts;
                combine[CombineCount - 1].mesh = tMF.sharedMesh;
                combine[CombineCount - 1].transform = tMF.transform.localToWorldMatrix;
            }

            GameObject tObj = new GameObject(tName);
            MeshFilter MF = tObj.AddComponent<MeshFilter>();
            Mesh tMesh = new Mesh();
            tMesh.CombineMeshes(combine);
            MF.sharedMesh = tMesh;
            MeshRenderer MR = tObj.AddComponent<MeshRenderer>();
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            tObj.transform.parent = KVP.Key.transform;
            Vector3[] tVerts = MF.sharedMesh.vertices;
            Vector3 tVect = tObj.transform.localPosition;
            //			float tHeight = 0f;
            for (int index = 0; index < tVerts.Length; index++)
            {
                tVerts[index] += tVect;
                if (tName.ToLower().EndsWith("-stretchext"))
                    tVerts[index] += new Vector3(0f, 0.01f);
            }
            MF.sharedMesh.vertices = tVerts;
            tObj.transform.localPosition = new Vector3(0f, 0f, 0f);
            MF.sharedMesh.RecalculateBounds();
            MF.sharedMesh.RecalculateNormals();
            MF.sharedMesh.tangents = GSDRootUtil.ProcessTangents(MF.sharedMesh.triangles, MF.sharedMesh.normals, MF.sharedMesh.uv, MF.sharedMesh.vertices);
            if (tRoad.opt_bIsLightmapped)
            {
                UnityEditor.Unwrapping.GenerateSecondaryUVSet(MF.sharedMesh);
            }
            if (tRoad.opt_bIsLightmapped)
            {
                #if UNITY_2019_2_OR_NEWER
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.ContributeGI);
                #else
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.LightmapStatic);
                #endif
            }
            if (tRoad.opt_bIsStatic)
            {
                tObj.isStatic = true;
            }


            if (bMainPlates)
            {
                MeshCollider MC = tObj.AddComponent<MeshCollider>();
                MC.sharedMesh = MF.sharedMesh;
                MC.material = tRoad.RoadPhysicMaterial;
            }

            if (bMainPlates && tCenter != null)
            {
                Object.DestroyImmediate(tCenter);
            }

            SaveMesh(SaveMeshTypeEnum.Intersection, MF.sharedMesh, tRoad, tName);
        }


        private MeshFilter MeshSetup2_Intersection_Helper(ref Mesh xMesh, ref Vector2[] uv, ref Vector4[] tangents, ref GameObject MasterObj, string tName, string tMat, bool bCollider = false)
        {
            if (xMesh == null)
            {
                return null;
            }
            xMesh.uv = uv;
            xMesh.tangents = tangents;
            if (tRoad.opt_bIsLightmapped)
            {
                UnityEditor.Unwrapping.GenerateSecondaryUVSet(xMesh);
            }

            GameObject tObj = new GameObject(tName);
            tObj.transform.parent = MasterObj.transform;
            MeshFilter MF = tObj.AddComponent<MeshFilter>();
            MF.sharedMesh = xMesh;
            if (bCollider)
            {
                MeshCollider MC = tObj.AddComponent<MeshCollider>();
                MC.sharedMesh = MF.sharedMesh;
            }
            if (tMat.Length < 1)
            {
                return null;
            }
            MeshRenderer MR = tObj.AddComponent<MeshRenderer>();
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(tMat, MR);
            if (tRoad.opt_bIsLightmapped)
            {
                #if UNITY_2019_2_OR_NEWER
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.ContributeGI);
                #else
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.LightmapStatic);
                #endif
            }
            if (tRoad.opt_bIsStatic)
            {
                tObj.isStatic = true;
            }

            return MF;
        }
        #endregion


        private Mesh MeshSetup2_Helper(ref Mesh xMesh, Vector2[] uv, Vector4[] tangents, ref GameObject tObj, bool bMarker, bool bShoulder = false, bool bBridge = false)
        {
            xMesh.uv = uv;
            xMesh.tangents = tangents;
            if (tRoad.opt_bIsLightmapped)
            {
                UnityEditor.Unwrapping.GenerateSecondaryUVSet(xMesh);
            }
            MeshFilter MF = tObj.AddComponent<MeshFilter>();
            MF.sharedMesh = xMesh;
            MeshCollider MC = null;
            if (tRoad.opt_bUseMeshColliders)
            {
                MC = tObj.AddComponent<MeshCollider>();
                MC.sharedMesh = MF.sharedMesh;
            }
            MeshRenderer MR = tObj.AddComponent<MeshRenderer>();

            if (bShoulder)
            {
                int mCounter = 0;
                if (tRoad.ShoulderMaterial1 != null)
                {
                    mCounter += 1;
                    if (tRoad.ShoulderMaterial2 != null)
                    {
                        mCounter += 1;
                        if (tRoad.ShoulderMaterial3 != null)
                        {
                            mCounter += 1;
                            if (tRoad.ShoulderMaterial4 != null)
                            {
                                mCounter += 1;
                            }
                        }
                    }
                }

                if (mCounter > 0)
                {
                    Material[] tMats = new Material[mCounter];
                    if (tRoad.ShoulderMaterial1 != null)
                    {
                        tMats[0] = tRoad.ShoulderMaterial1;
                        if (tRoad.ShoulderMaterial2 != null)
                        {
                            tMats[1] = tRoad.ShoulderMaterial2;
                            if (tRoad.ShoulderMaterial3 != null)
                            {
                                tMats[2] = tRoad.ShoulderMaterial3;
                                if (tRoad.ShoulderMaterial4 != null)
                                {
                                    tMats[3] = tRoad.ShoulderMaterial4;
                                }
                            }
                        }
                    }
                    MR.materials = tMats;
                }
            }
            else
            {
                if (bMarker)
                {
                    int mCounter = 0;
                    if (tRoad.RoadMaterialMarker1 != null)
                    {
                        mCounter += 1;
                        if (tRoad.RoadMaterialMarker2 != null)
                        {
                            mCounter += 1;
                            if (tRoad.RoadMaterialMarker3 != null)
                            {
                                mCounter += 1;
                                if (tRoad.RoadMaterialMarker4 != null)
                                {
                                    mCounter += 1;
                                }
                            }
                        }
                    }

                    if (mCounter > 0)
                    {
                        Material[] tMats = new Material[mCounter];
                        if (tRoad.RoadMaterialMarker1 != null)
                        {
                            tMats[0] = tRoad.RoadMaterialMarker1;
                            if (tRoad.RoadMaterialMarker2 != null)
                            {
                                tMats[1] = tRoad.RoadMaterialMarker2;
                                if (tRoad.RoadMaterialMarker3 != null)
                                {
                                    tMats[2] = tRoad.RoadMaterialMarker3;
                                    if (tRoad.RoadMaterialMarker4 != null)
                                    {
                                        tMats[3] = tRoad.RoadMaterialMarker4;
                                    }
                                }
                            }
                        }
                        MR.materials = tMats;
                    }
                }
                else
                {
                    int mCounter = 0;
                    if (tRoad.RoadMaterial1 != null)
                    {
                        mCounter += 1;
                        if (tRoad.RoadMaterial2 != null)
                        {
                            mCounter += 1;
                            if (tRoad.RoadMaterial3 != null)
                            {
                                mCounter += 1;
                                if (tRoad.RoadMaterial4 != null)
                                {
                                    mCounter += 1;
                                }
                            }
                        }
                    }
                    if (mCounter > 0)
                    {
                        Material[] tMats = new Material[mCounter];
                        if (tRoad.RoadMaterial1 != null)
                        {
                            tMats[0] = tRoad.RoadMaterial1;
                            if (tRoad.RoadMaterial2 != null)
                            {
                                tMats[1] = tRoad.RoadMaterial2;
                                if (tRoad.RoadMaterial3 != null)
                                {
                                    tMats[2] = tRoad.RoadMaterial3;
                                    if (tRoad.RoadMaterial4 != null)
                                    {
                                        tMats[3] = tRoad.RoadMaterial4;
                                    }
                                }
                            }
                        }
                        MR.materials = tMats;
                    }

                    if (MC)
                    {
                        MC.sharedMaterial = tRoad.RoadPhysicMaterial;
                    }
                }
            }

            if (tRoad.opt_bIsLightmapped)
            {
                #if UNITY_2019_2_OR_NEWER
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.ContributeGI);
                #else
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(tObj, UnityEditor.StaticEditorFlags.LightmapStatic);
                #endif
            }
            if (tRoad.opt_bIsStatic)
            {
                tObj.isStatic = true;
            }

            return xMesh;
        }


        private bool MeshSetup2_Helper_RoadCuts(int i, ref Mesh zMesh, Vector2[] uv, Vector4[] tangents, ref GameObject MasterObj, bool bIsMarkers, out GameObject CreatedObj)
        {
            string tName = "RoadCut" + i.ToString();
            if (bIsMarkers)
            {
                tName = "Markers" + i.ToString();
            }
            CreatedObj = new GameObject(tName);

            if (!bIsMarkers)
            {
                RoadCutNodes[i].RoadCut_world = CreatedObj;
            }
            else
            {
                RoadCutNodes[i].RoadCut_marker = CreatedObj;
            }

            CreatedObj.transform.position = cut_RoadVectorsHome[i];
            zMesh.uv = uv;
            zMesh.tangents = tangents;
            if (tRoad.opt_bIsLightmapped)
            {
                UnityEditor.Unwrapping.GenerateSecondaryUVSet(zMesh);
            }
            MeshFilter MF = CreatedObj.AddComponent<MeshFilter>();
            MF.sharedMesh = zMesh;

            MeshCollider MC = null;
            if (tRoad.opt_bUseMeshColliders && !bIsMarkers)
            {
                MC = CreatedObj.AddComponent<MeshCollider>();
                if (MC.sharedMesh == null)
                {
                    MC.sharedMesh = MF.sharedMesh;
                }
            }
            MeshRenderer MR = CreatedObj.AddComponent<MeshRenderer>();

            //Disable shadows for road cuts and markers:
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            int mCounter = 0;
            bool bHasMats = false;

            if (bIsMarkers)
            {


                //Get the mat count:
                if (tRoad.RoadMaterialMarker1 != null)
                {
                    mCounter += 1;
                    if (tRoad.RoadMaterialMarker2 != null)
                    {
                        mCounter += 1;
                        if (tRoad.RoadMaterialMarker3 != null)
                        {
                            mCounter += 1;
                            if (tRoad.RoadMaterialMarker4 != null)
                            {
                                mCounter += 1;
                            }
                        }
                    }
                }
                //Apply mats:
                if (mCounter > 0)
                {
                    Material[] tMats = new Material[mCounter];
                    if (tRoad.RoadMaterialMarker1 != null)
                    {
                        tMats[0] = tRoad.RoadMaterialMarker1;
                        if (tRoad.RoadMaterialMarker2 != null)
                        {
                            tMats[1] = tRoad.RoadMaterialMarker2;
                            if (tRoad.RoadMaterialMarker3 != null)
                            {
                                tMats[2] = tRoad.RoadMaterialMarker3;
                                if (tRoad.RoadMaterialMarker4 != null)
                                {
                                    tMats[3] = tRoad.RoadMaterialMarker4;
                                }
                            }
                        }
                    }
                    MR.materials = tMats;
                    bHasMats = true;
                }
            }
            else
            {
                //Get the mat count:
                if (tRoad.RoadMaterial1 != null)
                {
                    mCounter += 1;
                    if (tRoad.RoadMaterial2 != null)
                    {
                        mCounter += 1;
                        if (tRoad.RoadMaterial3 != null)
                        {
                            mCounter += 1;
                            if (tRoad.RoadMaterial4 != null)
                            {
                                mCounter += 1;
                            }
                        }
                    }
                }
                //Apply mats:
                if (mCounter > 0)
                {
                    Material[] tMats = new Material[mCounter];
                    if (tRoad.RoadMaterial1 != null)
                    {
                        tMats[0] = tRoad.RoadMaterial1;
                        if (tRoad.RoadMaterial2 != null)
                        {
                            tMats[1] = tRoad.RoadMaterial2;
                            if (tRoad.RoadMaterial3 != null)
                            {
                                tMats[2] = tRoad.RoadMaterial3;
                                if (tRoad.RoadMaterial4 != null)
                                {
                                    tMats[3] = tRoad.RoadMaterial4;
                                }
                            }
                        }
                    }
                    MR.materials = tMats;
                    bHasMats = true;
                }
            }

            CreatedObj.transform.parent = MasterObj.transform;
            if (!bIsMarkers && MC != null)
            {
                MC.sharedMaterial = tRoad.RoadPhysicMaterial;
            }
            if (tRoad.opt_bIsLightmapped)
            {
                #if UNITY_2019_2_OR_NEWER
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(CreatedObj, UnityEditor.StaticEditorFlags.ContributeGI);
                #else
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(CreatedObj, UnityEditor.StaticEditorFlags.LightmapStatic);
                #endif
            }
            if (tRoad.opt_bIsStatic)
            {
                CreatedObj.isStatic = true;
            }

            return bHasMats;
        }


        private bool MeshSetup2_Helper_CutsShoulder(int i, ref Mesh zMesh, Vector2[] uv, Vector4[] tangents, ref GameObject MasterObj, bool bIsLeft, bool bIsMarkers, out GameObject CreatedObj)
        {

            string tName = "";
            if (bIsMarkers)
            {
                if (bIsLeft)
                {
                    tName = "Markers" + i.ToString();
                }
                else
                {
                    tName = "Markers" + i.ToString();
                }
            }
            else
            {
                if (bIsLeft)
                {
                    tName = "SCutL" + i.ToString();
                }
                else
                {
                    tName = "SCutR" + i.ToString();
                }
            }

            CreatedObj = new GameObject(tName);
            if (bIsLeft)
            {
                CreatedObj.transform.position = cut_ShoulderL_VectorsHome[i];
                if (!bIsMarkers)
                {
                    ShoulderCutsLNodes[i].ShoulderCutL_world = CreatedObj;
                }
                else
                {
                    ShoulderCutsLNodes[i].ShoulderCutL_marker = CreatedObj;
                }

            }
            else
            {
                CreatedObj.transform.position = cut_ShoulderR_VectorsHome[i];
                if (!bIsMarkers)
                {
                    ShoulderCutsRNodes[i].ShoulderCutR_world = CreatedObj;
                }
                else
                {
                    ShoulderCutsRNodes[i].ShoulderCutR_marker = CreatedObj;
                }
            }

            MeshCollider MC = null;
            if (tRoad.opt_bUseMeshColliders)
            {
                MC = CreatedObj.AddComponent<MeshCollider>();
            }

            zMesh.uv = uv;
            zMesh.tangents = tangents;
            if (tRoad.opt_bIsLightmapped)
            {
                UnityEditor.Unwrapping.GenerateSecondaryUVSet(zMesh);
            }
            MeshFilter MF = CreatedObj.AddComponent<MeshFilter>();
            MF.sharedMesh = zMesh;

            if (tRoad.opt_bUseMeshColliders)
            {
                if (MC.sharedMesh == null)
                {
                    MC.sharedMesh = MF.sharedMesh;
                }
            }
            int mCounter = 0;
            bool bHasMats = false;

            //Disable shadows for road cuts and markers:
            MeshRenderer MR = CreatedObj.AddComponent<MeshRenderer>();
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;

            if (bIsMarkers)
            {
                if (tRoad.ShoulderMaterialMarker1 != null)
                {
                    mCounter += 1;
                    if (tRoad.ShoulderMaterialMarker2 != null)
                    {
                        mCounter += 1;
                        if (tRoad.ShoulderMaterialMarker3 != null)
                        {
                            mCounter += 1;
                            if (tRoad.ShoulderMaterialMarker4 != null)
                            {
                                mCounter += 1;
                            }
                        }
                    }
                }
                if (mCounter > 0)
                {
                    Material[] tMats = new Material[mCounter];
                    if (tRoad.ShoulderMaterialMarker1 != null)
                    {
                        tMats[0] = tRoad.ShoulderMaterialMarker1;
                        if (tRoad.ShoulderMaterialMarker2 != null)
                        {
                            tMats[1] = tRoad.ShoulderMaterialMarker2;
                            if (tRoad.ShoulderMaterialMarker3 != null)
                            {
                                tMats[2] = tRoad.ShoulderMaterialMarker3;
                                if (tRoad.ShoulderMaterialMarker4 != null)
                                {
                                    tMats[3] = tRoad.ShoulderMaterialMarker4;
                                }
                            }
                        }
                    }

                    MR.materials = tMats;
                    bHasMats = true;
                }
            }
            else
            {
                if (tRoad.ShoulderMaterial1 != null)
                {
                    mCounter += 1;
                    if (tRoad.ShoulderMaterial2 != null)
                    {
                        mCounter += 1;
                        if (tRoad.ShoulderMaterial3 != null)
                        {
                            mCounter += 1;
                            if (tRoad.ShoulderMaterial4 != null)
                            {
                                mCounter += 1;
                            }
                        }
                    }
                }
                if (mCounter > 0)
                {
                    Material[] tMats = new Material[mCounter];
                    if (tRoad.ShoulderMaterial1 != null)
                    {
                        tMats[0] = tRoad.ShoulderMaterial1;
                        if (tRoad.ShoulderMaterial2 != null)
                        {
                            tMats[1] = tRoad.ShoulderMaterial2;
                            if (tRoad.ShoulderMaterial3 != null)
                            {
                                tMats[2] = tRoad.ShoulderMaterial3;
                                if (tRoad.ShoulderMaterial4 != null)
                                {
                                    tMats[3] = tRoad.ShoulderMaterial4;
                                }
                            }
                        }
                    }
                    MR.materials = tMats;
                    MR = null;
                    bHasMats = true;
                }
            }

            if (!bIsMarkers && MC != null)
            {
                MC.sharedMaterial = tRoad.ShoulderPhysicMaterial;
            }
            CreatedObj.transform.parent = MasterObj.transform;
            if (tRoad.opt_bIsLightmapped)
            {
                #if UNITY_2019_2_OR_NEWER
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(CreatedObj, UnityEditor.StaticEditorFlags.ContributeGI);
                #else
                UnityEditor.GameObjectUtility.SetStaticEditorFlags(CreatedObj, UnityEditor.StaticEditorFlags.LightmapStatic);
                #endif
            }
            if (tRoad.opt_bIsStatic)
            {
                CreatedObj.isStatic = true;
            }

            MF = null;
            MC = null;

            return bHasMats;
        }
        #endregion


        private static void SaveMesh(SaveMeshTypeEnum SaveType, Mesh tMesh, GSDRoad tRoad, string tName)
        {
            if (!tRoad.GSDRS.opt_bSaveMeshes)
            {
                return;
            }

            //string tSceneName = System.IO.Path.GetFileName(UnityEditor.EditorApplication.currentScene).ToLower().Replace(".unity","");
            string tSceneName = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().name;
            tSceneName = tSceneName.Replace("/", "");
            tSceneName = tSceneName.Replace(".", "");
            string tFolderName = "";
            if (SaveType == SaveMeshTypeEnum.Road)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Roads/";
            }
            else if (SaveType == SaveMeshTypeEnum.Shoulder)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Shoulders/";
            }
            else if (SaveType == SaveMeshTypeEnum.Intersection)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Intersections/";
            }
            else if (SaveType == SaveMeshTypeEnum.Railing)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Railings/";
            }
            else if (SaveType == SaveMeshTypeEnum.Center)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/CenterDividers/";
            }
            else if (SaveType == SaveMeshTypeEnum.RoadCut)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Roads/Cuts/";
            }
            else if (SaveType == SaveMeshTypeEnum.SCut)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/Shoulders/Cuts/";
            }
            else if (SaveType == SaveMeshTypeEnum.RoadConn)
            {
                tFolderName = GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Generated/RoadConn/";
            }

            string xPath = Application.dataPath.Replace("/Assets", "/" + tFolderName);
            if (!System.IO.Directory.Exists(xPath))
            {
                System.IO.Directory.CreateDirectory(xPath);
            }

            string tRoadName = tRoad.transform.name;
            string FinalName = tFolderName + tSceneName + "-" + tRoadName + "-" + tName + ".asset";
            if (SaveType == SaveMeshTypeEnum.Intersection)
            {
                FinalName = tFolderName + tSceneName + "-" + tName + ".asset";
            }

            UnityEditor.AssetDatabase.CreateAsset(tMesh, FinalName);
        }
    }


    public static class GSDGeneralEditor
    {
        #region "Terrain history serialization"
        //http://forum.unity3d.com/threads/32647-C-Sharp-Binary-Serialization
        //http://answers.unity3d.com/questions/363477/c-how-to-setup-a-binary-serialization.html

        // === This is required to guarantee a fixed serialization assembly name, which Unity likes to randomize on each compile
        // Do not change this
        public sealed class VersionDeserializationBinder : SerializationBinder
        {
            public override System.Type BindToType(string assemblyName, string typeName)
            {
                if (!string.IsNullOrEmpty(assemblyName) && !string.IsNullOrEmpty(typeName))
                {
                    System.Type typeToDeserialize = null;
                    assemblyName = System.Reflection.Assembly.GetExecutingAssembly().FullName;
                    // The following line of code returns the type.
                    typeToDeserialize = System.Type.GetType(string.Format("{0}, {1}", typeName, assemblyName));
                    return typeToDeserialize;
                }
                return null;
            }
        }


        public static void TerrainHistory_Save(List<GSDTerrainHistoryMaker> tObj, GSDRoad tRoad)
        {
            string tPath = CheckNonAssetDirTH() + GetRoadTHFilename(ref tRoad);
            if (string.IsNullOrEmpty(tPath) || tPath.Length < 2)
            {
                return;
            }
            Stream stream = File.Open(tPath, FileMode.Create);
            BinaryFormatter bformatter = new BinaryFormatter();
            bformatter.Binder = new VersionDeserializationBinder();
            bformatter.Serialize(stream, tObj);
            tRoad.TerrainHistoryByteSize = (stream.Length * 0.001f).ToString("n0") + " kb";
            stream.Close();
        }


        public static void TerrainHistory_Delete(GSDRoad tRoad)
        {
            string tPath = CheckNonAssetDirTH() + GetRoadTHFilename(ref tRoad);
            if (System.IO.File.Exists(tPath))
            {
                System.IO.File.Delete(tPath);
            }
        }


        public static List<GSDTerrainHistoryMaker> TerrainHistory_Load(GSDRoad tRoad)
        {
            string tPath = CheckNonAssetDirTH() + GetRoadTHFilename(ref tRoad);
            if (string.IsNullOrEmpty(tPath) || tPath.Length < 2)
            {
                return null;
            }
            if (!File.Exists(tPath))
            {
                return null;
            }
            List<GSDTerrainHistoryMaker> result;
            Stream stream = File.Open(tPath, FileMode.Open);
            BinaryFormatter bFormatter = new BinaryFormatter();
            bFormatter.Binder = new VersionDeserializationBinder();
            //			try{
            result = (List<GSDTerrainHistoryMaker>) bFormatter.Deserialize(stream) as List<GSDTerrainHistoryMaker>;
            //			}catch{
            //				result = null;	
            //			}
            stream.Close();
            return result;
        }


        private static string GetRoadTHFilename(ref GSDRoad tRoad)
        {
            //string tSceneName = System.IO.Path.GetFileName(UnityEditor.EditorApplication.currentScene).ToLower().Replace(".unity","");
            string tSceneName = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().name;
            tSceneName = tSceneName.Replace("/", "");
            tSceneName = tSceneName.Replace(".", "");
            string tRoadName = tRoad.GSDRS.transform.name.Replace("RoadArchitectSystem", "RAS") + "-" + tRoad.transform.name;
            return tSceneName + "-" + tRoadName + "-TH.gsd";
        }


        public static string CheckNonAssetDir()
        {
            string tPath = GSDRootUtil.Dir_GetBase();
            if (!System.IO.Directory.Exists(tPath))
            {
                System.IO.Directory.CreateDirectory(tPath);
            }
            if (System.IO.Directory.Exists(tPath))
            {
                return tPath + "/";
            }
            else
            {
                return "";
            }
        }


        public static string CheckNonAssetDirTH()
        {
            CheckNonAssetDir();
            string xPath = GSDRootUtil.Dir_GetTH();
            if (!System.IO.Directory.Exists(xPath))
            {
                System.IO.Directory.CreateDirectory(xPath);
            }
            if (System.IO.Directory.Exists(xPath))
            {
                return xPath;
            }
            else
            {
                return "";
            }
        }


        public static string CheckNonAssetDirLibrary()
        {
            CheckNonAssetDir();
            string xPath = GSDRootUtil.Dir_GetLibrary();
            if (!System.IO.Directory.Exists(xPath))
            {
                System.IO.Directory.CreateDirectory(xPath);
            }
            if (System.IO.Directory.Exists(xPath))
            {
                return xPath;
            }
            else
            {
                return "";
            }
        }


        public static void CheckNonAssetDirs()
        {
            CheckNonAssetDir();
            CheckNonAssetDirTH();
            CheckNonAssetDirLibrary();
        }
        #endregion
    }


    public static class GSDRoadUtil
    {
        private const string FileSepString = "\n!!!! MICROGSD !!!!\n";
        private const string FileSepStringCRLF = "\r\n!!!! MICROGSD !!!!\r\n";


        public static Terrain GetTerrain(Vector3 tVect)
        {
            return GetTerrain_Do(ref tVect);
        }


        private static Terrain GetTerrain_Do(ref Vector3 tVect)
        {
            //Sphere cast 5m first. Then raycast down 1000m, then up 1000m.
            Collider[] tColliders = Physics.OverlapSphere(tVect, 10f);
            if (tColliders != null)
            {
                int tCollidersLength = tColliders.Length;
                for (int index = 0; index < tCollidersLength; index++)
                {
                    Terrain tTerrain = tColliders[index].transform.GetComponent<Terrain>();
                    if (tTerrain)
                    {
                        tColliders = null;
                        return tTerrain;
                    }
                }
                tColliders = null;
            }

            RaycastHit[] tHits;
            tHits = Physics.RaycastAll(tVect, Vector3.down, 1000f);
            int tHitsLength = 0;
            if (tHits != null)
            {
                tHitsLength = tHits.Length;
                for (int index = 0; index < tHitsLength; index++)
                {
                    Terrain tTerrain = tHits[index].collider.transform.GetComponent<Terrain>();
                    if (tTerrain)
                    {
                        tHits = null;
                        return tTerrain;
                    }
                }
                tHits = null;
            }

            tHits = Physics.RaycastAll(tVect, Vector3.up, 1000f);
            if (tHits != null)
            {
                tHitsLength = tHits.Length;
                for (int i = 0; i < tHitsLength; i++)
                {
                    Terrain tTerrain = tHits[i].collider.transform.GetComponent<Terrain>();
                    if (tTerrain)
                    {
                        tHits = null;
                        return tTerrain;
                    }
                }
                tHits = null;
            }
            return null;
        }


        #region "Terrain history"
        public static void ConstructRoad_StoreTerrainHistory(ref GSDRoad tRoad)
        {
            ConstructRoad_DoStoreTerrainHistory(ref tRoad);
        }


        private static void ConstructRoad_DoStoreTerrainHistory(ref GSDRoad tRoad)
        {
            Object[] TIDs = GameObject.FindObjectsOfType(typeof(GSDTerrain));

            HashSet<int> tTIDS = new HashSet<int>();
            foreach (GSDTerrain TID in TIDs)
            {
                tTIDS.Add(TID.GSDID);
            }

            if (tRoad.TerrainHistory != null && tRoad.TerrainHistory.Count > 0)
            {
                //Delete unnecessary terrain histories:
                foreach (GSDTerrainHistoryMaker THf in tRoad.TerrainHistory)
                {
                    if (!tTIDS.Contains(THf.TID))
                    {
                        THf.Nullify();
                        THf.bDestroyMe = true;
                    }
                }

                int hCount = tRoad.TerrainHistory.Count;
                for (int index = hCount - 1; index >= 0; index--)
                {
                    if (tRoad.TerrainHistory[index].bDestroyMe)
                    {
                        GSDTerrainHistoryMaker THf = tRoad.TerrainHistory[index];
                        tRoad.TerrainHistory.RemoveAt(index);
                        if (THf != null)
                        {
                            THf = null;
                        }
                    }
                }
            }

            if (tRoad.TerrainHistory == null)
            {
                tRoad.TerrainHistory = new List<GSDTerrainHistoryMaker>();
            }
            foreach (GSDTerraforming.TempTerrainData TTD in tRoad.EditorTTDList)
            {
                GSDTerrainHistoryMaker TH = null;
                GSDTerrain TID = null;
                //Get TID:
                foreach (GSDTerrain _TID in TIDs)
                {
                    if (_TID.GSDID == TTD.GSDID)
                    {
                        TID = _TID;
                    }
                }

                if (tRoad.TerrainHistory == null)
                {
                    tRoad.TerrainHistory = new List<GSDTerrainHistoryMaker>();
                }
                if (TID == null)
                {
                    continue;
                }

                int THCount = tRoad.TerrainHistory.Count;
                bool bContainsTID = false;
                for (int index = 0; index < THCount; index++)
                {
                    if (tRoad.TerrainHistory[index].TID == TID.GSDID)
                    {
                        bContainsTID = true;
                        break;
                    }
                }

                if (!bContainsTID)
                {
                    GSDTerrainHistoryMaker THx = new GSDTerrainHistoryMaker();
                    THx.TID = TID.GSDID;
                    tRoad.TerrainHistory.Add(THx);
                }

                TH = null;
                for (int index = 0; index < THCount; index++)
                {
                    if (tRoad.TerrainHistory[index].TID == TID.GSDID)
                    {
                        TH = tRoad.TerrainHistory[index];
                        break;
                    }
                }
                if (TH == null)
                {
                    continue;
                }

                //Heights:
                if (tRoad.opt_HeightModEnabled)
                {
                    if (TTD.cX != null && TTD.cY != null)
                    {
                        TH.x1 = new int[TTD.cI];
                        System.Array.Copy(TTD.cX, 0, TH.x1, 0, TTD.cI);
                        TH.y1 = new int[TTD.cI];
                        System.Array.Copy(TTD.cY, 0, TH.y1, 0, TTD.cI);
                        TH.h = new float[TTD.cI];
                        System.Array.Copy(TTD.oldH, 0, TH.h, 0, TTD.cI);
                        TH.cI = TTD.cI;
                    }
                }
                else
                {
                    TH.x1 = null;
                    TH.y1 = null;
                    TH.h = null;
                    TH.cI = 0;
                }
                //Details:
                if (tRoad.opt_DetailModEnabled)
                {
                    int TotalSize = 0;
                    for (int i = 0; i < TTD.DetailLayersCount; i++)
                    {
                        TotalSize += TTD.DetailsI[i];
                    }

                    //					float tHalf = (float)TotalSize / 2f;
                    //					int IntHalf = Mathf.CeilToInt(tHalf);

                    TH.DetailsX = new int[TotalSize];
                    TH.DetailsY = new int[TotalSize];
                    TH.DetailsOldValue = new int[TotalSize];

                    int RunningIndex = 0;
                    int cLength = 0;
                    for (int index = 0; index < TTD.DetailLayersCount; index++)
                    {
                        cLength = TTD.DetailsI[index];
                        if (cLength < 1)
                        {
                            continue;
                        }
                        System.Array.Copy(TTD.DetailsX[index].ToArray(), 0, TH.DetailsX, RunningIndex, cLength);
                        System.Array.Copy(TTD.DetailsY[index].ToArray(), 0, TH.DetailsY, RunningIndex, cLength);
                        System.Array.Copy(TTD.OldDetailsValue[index].ToArray(), 0, TH.DetailsOldValue, RunningIndex, cLength);
                        RunningIndex += TTD.DetailsI[index];
                    }

                    //                    TH.DetailsX = TTD.DetailsX;
                    //                    TH.DetailsY = TTD.DetailsY;
                    //                    TH.DetailsOldValue = TTD.OldDetailsValue;
                    TH.DetailsI = TTD.DetailsI;
                    TH.DetailLayersCount = TTD.DetailLayersCount;
                }
                else
                {
                    TH.DetailsX = null;
                    TH.DetailsY = null;
                    TH.DetailsOldValue = null;
                    TH.DetailsI = null;
                    TH.DetailLayersCount = 0;
                }
                //Trees:
                if (tRoad.opt_TreeModEnabled)
                {
                    if (TTD.TreesOld != null)
                    {
                        TH.MakeGSDTrees(ref TTD.TreesOld);
                        TTD.TreesOld.Clear();
                        TTD.TreesOld = null;
                        TH.TreesI = TTD.TreesI;
                    }
                }
                else
                {
                    TH.TreesOld = null;
                    TH.TreesI = 0;
                }
            }

            //			//TerrainHistoryRaw
            //			GSDRootUtil.StartProfiling(tRoad, "TerrainHistorySerialize");
            //			TerrainHistorySerialize(ref tRoad);
            //			GSDRootUtil.EndProfiling(tRoad);
        }


        //		private static void TerrainHistorySerialize(ref GSDRoad tRoad) {
        //			MemoryStream ms = new MemoryStream();
        //	        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        //			formatter.Serialize(ms,tRoad.TerrainHistory);
        //			ms.Close();
        //			tRoad.TerrainHistoryRaw = ms.ToArray();
        //	        ms = null;
        //	    }
        //		
        //		private static void TerrainHistoryDeserialize(ref GSDRoad tRoad) {
        //			MemoryStream ms = new MemoryStream(tRoad.TerrainHistoryRaw);
        //	        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        //			tRoad.TerrainHistory = (List<GSDTerrainHistoryMaker>)formatter.Deserialize(ms);
        //			ms.Close();
        //	        ms = null;
        //	    }


        public static void ConstructRoad_ResetTerrainHistory(ref GSDRoad tRoad)
        {
            ConstructRoad_DoResetTerrainHistory(ref tRoad);
        }


        private static void ConstructRoad_DoResetTerrainHistory(ref GSDRoad tRoad)
        {
            if (tRoad.TerrainHistory != null)
            {
                tRoad.TerrainHistory.Clear();
                tRoad.TerrainHistory = null;
            }
        }
        #endregion


        [System.Serializable]
        public class Construction3DTri
        {
            public Vector3 P1, P2, P3;
            const float NearDist = 0.15f;
            const float NearDistSQ = 0.0225f;
            Vector2[] poly2D;
            Vector3[] poly3D;
            public float MaxDistance = 200f;
            public float MaxDistanceSq = 200f;
            public Vector3 normal = default(Vector3);
            public Vector3 pMiddle = default(Vector3);
            public float MinI = 0f;
            public float MaxI = 1f;


            public Construction3DTri(Vector3 _P1, Vector3 _P2, Vector3 _P3, float _MinI, float _MaxI)
            {
                MinI = _MinI;
                MaxI = _MaxI;
                P1 = _P1;
                P2 = _P2;
                P3 = _P3;

                poly2D = new Vector2[3];
                poly2D[0] = new Vector2(P1.x, P1.z);
                poly2D[1] = new Vector2(P2.x, P2.z);
                poly2D[2] = new Vector2(P3.x, P3.z);

                poly3D = new Vector3[3];
                poly3D[0] = P1;
                poly3D[1] = P2;
                poly3D[2] = P3;

                float[] tMaxes = new float[3];
                tMaxes[0] = Vector3.Distance(P1, P2);
                tMaxes[1] = Vector3.Distance(P1, P3);
                tMaxes[2] = Vector3.Distance(P2, P3);
                MaxDistance = Mathf.Max(tMaxes) * 1.5f;

                float[] tMaxesSQ = new float[3];
                tMaxesSQ[0] = Vector3.SqrMagnitude(P1 - P2);
                tMaxesSQ[1] = Vector3.SqrMagnitude(P1 - P3);
                tMaxesSQ[2] = Vector3.SqrMagnitude(P2 - P3);
                MaxDistanceSq = Mathf.Max(tMaxesSQ) * 1.5f;

                PlaneFrom3Points(out normal, out pMiddle, P1, P2, P3);

                normal = Vector3.Cross((P3 - P1), (P2 - P1));

                ////				//This creates middle point:
                //				Vector3 tMiddle1 = ((P3-P1)*0.5f)+P1;
                //				Vector3 tMiddle2 = ((P2-P1)*0.5f)+P1;
                //				pMiddle = ((tMiddle2-tMiddle1)*0.5f)+tMiddle1;
            }


            //Get the intersection between a line and a plane. 
            //If the line and plane are not parallel, the function outputs true, otherwise false.
            public Vector3 LinePlaneIntersection(ref Vector3 F1)
            {
                F1.y = 0f;

                //calculate the distance between the linePoint and the line-plane intersection point
                float dotNumerator = Vector3.Dot((pMiddle - F1), normal);
                float dotDenominator = Vector3.Dot(Vector3.up.normalized, normal);

                //line and plane are not parallel
                if (!GSDRootUtil.IsApproximately(0f, dotDenominator, 0.001f))
                {
                    //get the coordinates of the line-plane intersection point
                    return (F1 + (Vector3.up.normalized * (dotNumerator / dotDenominator)));
                }
                else
                {
                    //output not valid
                    return default(Vector3);
                }
            }


            //Convert a plane defined by 3 points to a plane defined by a vector and a point. 
            //The plane point is the middle of the triangle defined by the 3 points.
            public static void PlaneFrom3Points(out Vector3 planeNormal, out Vector3 planePoint, Vector3 pointA, Vector3 pointB, Vector3 pointC)
            {
                planeNormal = Vector3.zero;
                planePoint = Vector3.zero;

                //Make two vectors from the 3 input points, originating from point A
                Vector3 AB = pointB - pointA;
                Vector3 AC = pointC - pointA;

                //Calculate the normal
                planeNormal = Vector3.Normalize(Vector3.Cross(AB, AC));

                //Get the points in the middle AB and AC
                Vector3 middleAB = pointA + (AB / 2.0f);
                Vector3 middleAC = pointA + (AC / 2.0f);

                //Get vectors from the middle of AB and AC to the point which is not on that line.
                Vector3 middleABtoC = pointC - middleAB;
                Vector3 middleACtoB = pointB - middleAC;

                //Calculate the intersection between the two lines. This will be the center 
                //of the triangle defined by the 3 points.
                //We could use LineLineIntersection instead of ClosestPointsOnTwoLines but due to rounding errors 
                //this sometimes doesn't work.
                Vector3 temp;
                ClosestPointsOnTwoLines(out planePoint, out temp, middleAB, middleABtoC, middleAC, middleACtoB);
            }


            //Two non-parallel lines which may or may not touch each other have a point on each line which are closest
            //to each other. This function finds those two points. If the lines are not parallel, the function 
            //outputs true, otherwise false.
            public static bool ClosestPointsOnTwoLines(out Vector3 closestPointLine1, out Vector3 closestPointLine2, Vector3 linePoint1, Vector3 lineVec1, Vector3 linePoint2, Vector3 lineVec2)
            {

                closestPointLine1 = Vector3.zero;
                closestPointLine2 = Vector3.zero;

                float a = Vector3.Dot(lineVec1, lineVec1);
                float b = Vector3.Dot(lineVec1, lineVec2);
                float e = Vector3.Dot(lineVec2, lineVec2);

                float d = a * e - b * b;

                //lines are not parallel
                if (d != 0.0f)
                {

                    Vector3 r = linePoint1 - linePoint2;
                    float c = Vector3.Dot(lineVec1, r);
                    float f = Vector3.Dot(lineVec2, r);

                    float s = (b * f - c * e) / d;
                    float t = (a * f - c * b) / d;

                    closestPointLine1 = linePoint1 + lineVec1 * s;
                    closestPointLine2 = linePoint2 + lineVec2 * t;

                    return true;
                }

                else
                {
                    return false;
                }
            }


            //create a vector of direction "vector" with length "size"
            public static Vector3 SetVectorLength(Vector3 vector, float size)
            {

                //normalize the vector
                Vector3 vectorNormalized = Vector3.Normalize(vector);

                //scale the vector
                return vectorNormalized *= size;
            }


            //			public bool Contains2D(ref Vector2 p){
            //				return Contains2D_Do(ref p);
            //			}
            public bool Contains2D(ref Vector2 p)
            {
                if (Vector2.SqrMagnitude(p - poly2D[0]) > MaxDistanceSq)
                {
                    return false;
                }
                //				if(Vector2.Distance(p,P1) > MaxDistance){ return false; }
                //				if(poly2D.Length != 3){ return false; }

                Vector2 x1 = default(Vector2);
                Vector2 x2 = default(Vector2);
                Vector2 oldPoint = default(Vector2);
                Vector2 newPoint = default(Vector2);
                bool inside = false;

                inside = false;
                oldPoint = new Vector2(poly2D[3 - 1].x, poly2D[3 - 1].y);
                for (int index = 0; index < 3; index++)
                {
                    newPoint = new Vector2(poly2D[index].x, poly2D[index].y);
                    if (newPoint.x > oldPoint.x)
                    {
                        x1 = oldPoint;
                        x2 = newPoint;
                    }
                    else
                    {
                        x1 = newPoint;
                        x2 = oldPoint;
                    }
                    if ((newPoint.x < p.x) == (p.x <= oldPoint.x) && (p.y - x1.y) * (x2.x - x1.x) < (x2.y - x1.y) * (p.x - x1.x))
                    {
                        inside = !inside;
                    }
                    oldPoint = newPoint;
                }
                return inside;
            }


            public bool Contains2D(ref Vector3 p)
            {
                Vector2 tVect = new Vector2(p.x, p.z);
                return Contains2D(ref tVect);
            }


            public bool Near(ref Vector3 tVect, out Vector3 TheNearVect)
            {
                if (Vector3.SqrMagnitude(tVect - P1) > MaxDistanceSq)
                {
                    //				if(Vector3.Distance(tVect,P1) > MaxDistance){ 
                    TheNearVect = default(Vector3);
                    return false;
                }

                //				if(Vector3.Distance(tVect,P1) < NearDist){
                if (Vector3.SqrMagnitude(tVect - P1) < NearDistSQ)
                {
                    TheNearVect = P1;
                    return true;
                }
                //				if(Vector3.Distance(tVect,P2) < NearDist){
                if (Vector3.SqrMagnitude(tVect - P2) < NearDistSQ)
                {
                    TheNearVect = P2;
                    return true;
                }
                //				if(Vector3.Distance(tVect,P3) < NearDist){
                if (Vector3.SqrMagnitude(tVect - P3) < NearDistSQ)
                {
                    TheNearVect = P3;
                    return true;
                }
                TheNearVect = default(Vector3);
                return false;
            }


            public string ToStringGSD()
            {
                return ("P1:" + P1.ToString() + " P2:" + P2.ToString() + " P3:" + P3.ToString());
            }
        }


        public class Construction2DRect
        {
            public Vector2 P1, P2, P3, P4;
            private const float NearDist = 0.15f;
            private const float NearDistSQ = 0.0225f;
            private Vector2[] poly;
            public float MaxDistance = 200f;
            public float MaxDistanceSQ = 200f;
            public float Height = 0f;
            public float MinI = 0f;
            public float MaxI = 0f;


            public Construction2DRect(Vector2 _P1, Vector2 _P2, Vector2 _P3, Vector2 _P4, float tHeight = 0f)
            {
                Construction2DRect_Do(ref _P1, ref _P2, ref _P3, ref _P4, ref tHeight);
            }


            private void Construction2DRect_Do(ref Vector2 _P1, ref Vector2 _P2, ref Vector2 _P3, ref Vector2 _P4, ref float tHeight)
            {
                P1 = _P1;
                P2 = _P2;
                P3 = _P3;
                P4 = _P4;
                Height = tHeight;

                if (GSDRootUtil.IsApproximately(P1.x, P2.x, 0.0001f))
                {
                    P2.x += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P1.x, P3.x, 0.0001f))
                {
                    P3.x += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P1.x, P4.x, 0.0001f))
                {
                    P4.x += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P2.x, P3.x, 0.0001f))
                {
                    P3.x += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P2.x, P4.x, 0.0001f))
                {
                    P4.x += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P3.x, P4.x, 0.0001f))
                {
                    P4.x += 0.0002f;
                }

                if (GSDRootUtil.IsApproximately(P1.y, P2.y, 0.0001f))
                {
                    P2.y += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P1.y, P3.y, 0.0001f))
                {
                    P3.y += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P1.y, P4.y, 0.0001f))
                {
                    P4.y += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P2.y, P3.y, 0.0001f))
                {
                    P3.y += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P2.y, P4.y, 0.0001f))
                {
                    P4.y += 0.0002f;
                }
                if (GSDRootUtil.IsApproximately(P3.y, P4.y, 0.0001f))
                {
                    P4.y += 0.0002f;
                }

                //Find two with smallest x, etc		
                float[] tX = new float[4];
                float[] tY = new float[4];

                tX[0] = P1.x;
                tX[1] = P2.x;
                tX[2] = P3.x;
                tX[3] = P4.x;

                tY[0] = P1.y;
                tY[1] = P2.y;
                tY[2] = P3.y;
                tY[3] = P4.y;

                float MinX1, MinX2;
                bool bIgnoreP1, bIgnoreP2, bIgnoreP3, bIgnoreP4;
                bIgnoreP1 = bIgnoreP2 = bIgnoreP3 = bIgnoreP4 = false;

                //Get top two minimum X
                MinX1 = Mathf.Min(tX);
                tX = new float[3];
                int tCounter = 0;
                if (!GSDRootUtil.IsApproximately(MinX1, P1.x, 0.0001f))
                {
                    tX[tCounter] = P1.x;
                    tCounter += 1;
                }
                if (!GSDRootUtil.IsApproximately(MinX1, P2.x, 0.0001f))
                {
                    tX[tCounter] = P2.x;
                    tCounter += 1;
                }
                if (!GSDRootUtil.IsApproximately(MinX1, P3.x, 0.0001f))
                {
                    tX[tCounter] = P3.x;
                    tCounter += 1;
                }
                if (!GSDRootUtil.IsApproximately(MinX1, P4.x, 0.0001f))
                {
                    tX[tCounter] = P4.x;
                    tCounter += 1;
                }
                MinX2 = Mathf.Min(tX);

                Vector2 xMin1 = default(Vector2);
                Vector2 xMin2 = default(Vector2);
                if (GSDRootUtil.IsApproximately(MinX1, P1.x, 0.0001f))
                {
                    xMin1 = P1;
                    bIgnoreP1 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX1, P2.x, 0.0001f))
                {
                    xMin1 = P2;
                    bIgnoreP2 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX1, P3.x, 0.0001f))
                {
                    xMin1 = P3;
                    bIgnoreP3 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX1, P4.x, 0.0001f))
                {
                    xMin1 = P4;
                    bIgnoreP4 = true;
                }

                if (GSDRootUtil.IsApproximately(MinX2, P1.x, 0.0001f))
                {
                    xMin2 = P1;
                    bIgnoreP1 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX2, P2.x, 0.0001f))
                {
                    xMin2 = P2;
                    bIgnoreP2 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX2, P3.x, 0.0001f))
                {
                    xMin2 = P3;
                    bIgnoreP3 = true;
                }
                else if (GSDRootUtil.IsApproximately(MinX2, P4.x, 0.0001f))
                {
                    xMin2 = P4;
                    bIgnoreP4 = true;
                }

                Vector2 TopLeft = default(Vector2);
                Vector2 BottomLeft = default(Vector2);
                if (xMin1.y > xMin2.y)
                {
                    TopLeft = xMin1;
                    BottomLeft = xMin2;
                }
                else
                {
                    TopLeft = xMin2;
                    BottomLeft = xMin1;
                }

                Vector2 xMax1 = default(Vector2);
                Vector2 xMax2 = default(Vector2);
                bool bXmax1 = false;
                if (!bIgnoreP1)
                {
                    xMax1 = P1;
                    bXmax1 = true;
                }
                if (!bIgnoreP2)
                {
                    if (bXmax1)
                    {
                        xMax2 = P2;
                    }
                    else
                    {
                        xMax1 = P2;
                        bXmax1 = true;
                    }
                }
                if (!bIgnoreP3)
                {
                    if (bXmax1)
                    {
                        xMax2 = P3;
                    }
                    else
                    {
                        xMax1 = P3;
                        bXmax1 = true;
                    }
                }
                if (!bIgnoreP4)
                {
                    if (bXmax1)
                    {
                        xMax2 = P4;
                    }
                    else
                    {
                        xMax1 = P4;
                        bXmax1 = true;
                    }
                }

                Vector2 TopRight = default(Vector2);
                Vector2 BottomRight = default(Vector2);
                if (xMax1.y > xMax2.y)
                {
                    TopRight = xMax1;
                    BottomRight = xMax2;
                }
                else
                {
                    TopRight = xMax2;
                    BottomRight = xMax1;
                }

                P1 = BottomLeft;
                P2 = BottomRight;
                P3 = TopRight;
                P4 = TopLeft;

                poly = new Vector2[4];
                poly[0] = P1;
                poly[1] = P2;
                poly[2] = P3;
                poly[3] = P4;

                float[] tMaxes = new float[6];
                tMaxes[0] = Vector2.Distance(P1, P2);
                tMaxes[1] = Vector2.Distance(P1, P3);
                tMaxes[2] = Vector2.Distance(P1, P4);
                tMaxes[3] = Vector2.Distance(P2, P3);
                tMaxes[4] = Vector2.Distance(P2, P4);
                tMaxes[5] = Vector2.Distance(P3, P4);
                MaxDistance = Mathf.Max(tMaxes) * 1.5f;

                float[] tMaxesSQ = new float[6];
                tMaxesSQ[0] = Vector2.SqrMagnitude(P1 - P2);
                tMaxesSQ[1] = Vector2.SqrMagnitude(P1 - P3);
                tMaxesSQ[2] = Vector2.SqrMagnitude(P1 - P4);
                tMaxesSQ[3] = Vector2.SqrMagnitude(P2 - P3);
                tMaxesSQ[4] = Vector2.SqrMagnitude(P2 - P4);
                tMaxesSQ[5] = Vector2.SqrMagnitude(P3 - P4);
                MaxDistanceSQ = Mathf.Max(tMaxesSQ) * 1.5f;
            }



            private Vector2 x1 = default(Vector2);
            private Vector2 x2 = default(Vector2);
            private Vector2 oldPoint = default(Vector2);
            private Vector2 newPoint = default(Vector2);
            private bool inside = false;

            //				public bool Contains(ref Vector2 p){
            //					return Contains_Do(ref p);
            //				}
            public bool Contains(ref Vector2 p)
            {
                //					if(Vector2.Distance(p,P1) > MaxDistance){ return false; }
                if (Vector2.SqrMagnitude(p - P1) > MaxDistanceSQ)
                {
                    return false;
                }
                //					if(poly.Length != 4){ return false; }

                inside = false;
                oldPoint = new Vector2(poly[4 - 1].x, poly[4 - 1].y);
                for (int index = 0; index < 4; index++)
                {
                    newPoint = new Vector2(poly[index].x, poly[index].y);
                    if (newPoint.x > oldPoint.x)
                    {
                        x1 = oldPoint;
                        x2 = newPoint;
                    }
                    else
                    {
                        x1 = newPoint;
                        x2 = oldPoint;
                    }
                    if ((newPoint.x < p.x) == (p.x <= oldPoint.x) && (p.y - x1.y) * (x2.x - x1.x) < (x2.y - x1.y) * (p.x - x1.x))
                    {
                        inside = !inside;
                    }
                    oldPoint = newPoint;
                }
                return inside;
            }


            public bool Near(ref Vector2 tVect, out Vector2 TheNearVect)
            {
                if (Vector2.SqrMagnitude(tVect - P1) > MaxDistanceSQ)
                {
                    //					if(Vector2.Distance(tVect,P1) > MaxDistance){ 
                    TheNearVect = default(Vector2);
                    return false;
                }

                if (Vector2.SqrMagnitude(tVect - P1) < NearDistSQ)
                {
                    //					if(Vector2.Distance(tVect,P1) < NearDist){
                    TheNearVect = P1;
                    return true;
                }
                if (Vector2.SqrMagnitude(tVect - P2) < NearDistSQ)
                {
                    //					if(Vector2.Distance(tVect,P2) < NearDist){
                    TheNearVect = P2;
                    return true;
                }
                if (Vector2.SqrMagnitude(tVect - P3) < NearDistSQ)
                {
                    //					if(Vector2.Distance(tVect,P3) < NearDist){
                    TheNearVect = P3;
                    return true;
                }
                if (Vector2.SqrMagnitude(tVect - P4) < NearDistSQ)
                {
                    //					if(Vector2.Distance(tVect,P4) < NearDist){
                    TheNearVect = P4;
                    return true;
                }
                TheNearVect = default(Vector2);
                return false;
            }


            public string ToStringGSD()
            {
                return ("P1:" + P1.ToString() + " P2:" + P2.ToString() + " P3:" + P3.ToString() + " P4:" + P4.ToString());
            }
        }


        public static GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo[] GetRoadTerrainInfos()
        {
            Object[] tTerrainsObj = GameObject.FindObjectsOfType(typeof(Terrain));
            GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo tInfo;
            List<GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo> tInfos = new List<GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo>();
            foreach (Terrain tTerrain in tTerrainsObj)
            {
                tInfo = new GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo();
                tInfo.GSDID = tTerrain.transform.gameObject.GetComponent<GSDTerrain>().GSDID;
                tInfo.tBounds = new Rect(tTerrain.transform.position.x, tTerrain.transform.position.z, tTerrain.terrainData.size.x, tTerrain.terrainData.size.z);
                tInfo.hmWidth = tTerrain.terrainData.heightmapWidth;
                tInfo.hmHeight = tTerrain.terrainData.heightmapHeight;
                tInfo.tPos = tTerrain.transform.position;
                tInfo.tSize = tTerrain.terrainData.size;
                tInfo.heights = tTerrain.terrainData.GetHeights(0, 0, tInfo.hmWidth, tInfo.hmHeight);
                tInfos.Add(tInfo);
            }
            GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo[] fInfos = new GSD.Threaded.GSDRoadCreationT.RoadTerrainInfo[tInfos.Count];
            int fInfosLength = fInfos.Length;
            for (int index = 0; index < fInfosLength; index++)
            {
                fInfos[index] = tInfos[index];
            }
            tInfos = null;
            return fInfos;
        }


        // RenderQueue provides ID's for Unity render queues. These can be applied to sub-shader tags,
        // but it's easier to just set material.renderQueue. Static class instead of enum because these
        // are int's, so this way client code doesn't need to use typecasting.
        //
        // From the documentation:
        // For special uses in-between queues can be used. Internally each queue is represented
        // by integer index; Background is 1000, Geometry is 2000, Transparent is 3000 and
        // Overlay is 4000.
        //
        // NOTE: Keep these in numerical order for ease of understanding. Use plurals for start of
        // a group of layers.
        public static class RenderQueue
        {
            public const int Background = 1000;

            // Mid-ground.
            public const int ParallaxLayers = Background + 100; // +1, 2, 3, ... for additional layers

            // Lines on the ground.
            public const int GroundLines = Background + 200;

            public const int Tracks = GroundLines + 0;
            public const int Routes = GroundLines + 1;
            public const int IndicatorRings = GroundLines + 2;
            public const int Road = GroundLines + 3;

            public const int Geometry = 2000;


            public const int Transparent = 3000;

            // Lines on the screen. (Over world, but under GUI.)
            public const int ScreenLines = Transparent + 100;

            public const int Overlay = 4000;
        }


        public static void SaveNodeObjects(ref Splination.SplinatedMeshMaker[] tSplinatedObjects, ref EdgeObjects.EdgeObjectMaker[] tEdgeObjects, ref WizardObject WO)
        {
            SaveNodeObjects_DO(ref tSplinatedObjects, ref tEdgeObjects, ref WO);
        }


        private static void SaveNodeObjects_DO(ref Splination.SplinatedMeshMaker[] tSplinatedObjects, ref EdgeObjects.EdgeObjectMaker[] tEdgeObjects, ref WizardObject WO)
        {
            int sCount = tSplinatedObjects.Length;
            int eCount = tEdgeObjects.Length;
            //Splinated objects first:
            Splination.SplinatedMeshMaker SMM = null;
            GSDRootUtil.Dir_GetLibrary_CheckSpecialDirs();
            string xPath = GSDRootUtil.Dir_GetLibrary();
            string tPath = xPath + "B/" + WO.FileName + ".gsd";
            if (WO.bIsDefault)
            {
                tPath = xPath + "B/W/" + WO.FileName + ".gsd";
            }
            StringBuilder builder = new StringBuilder(32768);

            //Wizard object:
            builder.Append(WO.ConvertToString());
            builder.Append(FileSepString);

            for (int index = 0; index < sCount; index++)
            {
                SMM = tSplinatedObjects[index];
                builder.Append(SMM.ConvertToString());
                builder.Append(FileSepString);
            }

            EdgeObjects.EdgeObjectMaker EOM = null;
            for (int index = 0; index < eCount; index++)
            {
                EOM = tEdgeObjects[index];
                builder.Append(EOM.ConvertToString());
                builder.Append(FileSepString);
            }

#if UNITY_WEBPLAYER
			
#else
            System.IO.File.WriteAllText(tPath, builder.ToString());
#endif
        }


        public static void LoadNodeObjects(string tFileName, GSDSplineN tNode, bool bIsDefault = false, bool bIsBridge = false)
        {
#if UNITY_WEBPLAYER
			return;
#else

            string tPath = "";
            GSDRootUtil.Dir_GetLibrary_CheckSpecialDirs();
            string xPath = GSDRootUtil.Dir_GetLibrary();
            if (bIsDefault)
            {
                tPath = xPath + "B/W/" + tFileName + ".gsd";
            }
            else
            {
                tPath = xPath + "B/" + tFileName + ".gsd";
            }

            string tData = System.IO.File.ReadAllText(tPath);
            string[] tSep = new string[2];
            tSep[0] = FileSepString;
            tSep[1] = FileSepStringCRLF;
            string[] tSplit = tData.Split(tSep, System.StringSplitOptions.RemoveEmptyEntries);

            Splination.SplinatedMeshMaker SMM = null;
            Splination.SplinatedMeshMaker.SplinatedMeshLibraryMaker SLM = null;
            EdgeObjects.EdgeObjectMaker EOM = null;
            EdgeObjects.EdgeObjectMaker.EdgeObjectLibraryMaker ELM = null;
            int tSplitCount = tSplit.Length;

            for (int index = 0; index < tSplitCount; index++)
            {
                SLM = null;
                SLM = Splination.SplinatedMeshMaker.SLMFromData(tSplit[index]);
                if (SLM != null)
                {
                    SMM = tNode.AddSplinatedObject();
                    SMM.LoadFromLibraryBulk(ref SLM);
                    SMM.bToggle = false;
                    if (bIsBridge && tNode.bIsBridgeStart && tNode.bIsBridgeMatched && tNode.BridgeCounterpartNode != null)
                    {
                        SMM.StartTime = tNode.tTime;
                        SMM.EndTime = tNode.BridgeCounterpartNode.tTime;
                        SMM.StartPos = tNode.GSDSpline.GetSplineValue(SMM.StartTime);
                        SMM.EndPos = tNode.GSDSpline.GetSplineValue(SMM.EndTime);
                    }
                    continue;
                }

                ELM = null;
                ELM = EdgeObjects.EdgeObjectMaker.ELMFromData(tSplit[index]);
                if (ELM != null)
                {
                    EOM = tNode.AddEdgeObject();
                    EOM.LoadFromLibraryBulk(ref ELM);
                    EOM.bToggle = false;
                    if (!EOM.bSingle && bIsBridge && tNode.bIsBridgeStart && tNode.bIsBridgeMatched && tNode.BridgeCounterpartNode != null)
                    {
                        EOM.StartTime = tNode.tTime;
                        EOM.EndTime = tNode.BridgeCounterpartNode.tTime;
                        EOM.StartPos = tNode.GSDSpline.GetSplineValue(EOM.StartTime);
                        EOM.EndPos = tNode.GSDSpline.GetSplineValue(EOM.EndTime);
                    }
                    else if (EOM.bSingle && bIsBridge && tNode.BridgeCounterpartNode != null && tNode.bIsBridgeStart)
                    {
                        float tDist = (EOM.SingleOnlyBridgePercent * (tNode.BridgeCounterpartNode.tDist - tNode.tDist) + tNode.tDist);
                        EOM.SinglePosition = tNode.GSDSpline.TranslateDistBasedToParam(tDist);
                        EOM.StartPos = tNode.GSDSpline.GetSplineValue(EOM.SinglePosition);
                        EOM.EndPos = tNode.GSDSpline.GetSplineValue(EOM.SinglePosition);
                    }
                    continue;
                }
            }

            tNode.SetupSplinatedMeshes();
            tNode.SetupEdgeObjects();

#endif
        }


        #region "Splat maps"
        public static byte[] MakeSplatMap(Terrain tTerrain, Color tBG, Color tFG, int tWidth, int tHeight, float SplatWidth, bool bSkipBridge, bool bSkipTunnel, string xRoadUID = "")
        {
            return MakeSplatMapDo(tTerrain, tBG, tFG, tWidth, tHeight, SplatWidth, bSkipBridge, bSkipTunnel, xRoadUID);
        }


        private static byte[] MakeSplatMapDo(Terrain tTerrain, Color tBG, Color tFG, int tWidth, int tHeight, float SplatWidth, bool bSkipBridge, bool bSkipTunnel, string xRoadUID)
        {
            Texture2D tTexture = new Texture2D(tWidth, tHeight, TextureFormat.RGB24, false);

            //Set background color:
            Color[] tColorsBG = new Color[tWidth * tHeight];
            int tBGCount = tColorsBG.Length;
            for (int i = 0; i < tBGCount; i++)
            {
                tColorsBG[i] = tBG;
            }
            tTexture.SetPixels(0, 0, tWidth, tHeight, tColorsBG);
            tColorsBG = null;

            Object[] tRoads = null;
            if (xRoadUID != "")
            {
                tRoads = new Object[1];
                Object[] bRoads = GameObject.FindObjectsOfType(typeof(GSDRoad));
                foreach (GSDRoad fRoad in bRoads)
                {
                    if (string.CompareOrdinal(fRoad.UID, xRoadUID) == 0)
                    {
                        tRoads[0] = fRoad;
                        break;
                    }
                }
            }
            else
            {
                tRoads = GameObject.FindObjectsOfType(typeof(GSDRoad));
            }
            Vector3 tPos = tTerrain.transform.position;
            Vector3 tSize = tTerrain.terrainData.size;
            foreach (GSDRoad tRoad in tRoads)
            {
                GSDSplineC tSpline = tRoad.GSDSpline;
                int tCount = tSpline.RoadDefKeysArray.Length;

                Vector3 POS1 = default(Vector3);
                Vector3 POS2 = default(Vector3);

                Vector3 tVect = default(Vector3);
                Vector3 tVect2 = default(Vector3);
                Vector3 lVect1 = default(Vector3);
                Vector3 lVect2 = default(Vector3);
                Vector3 rVect1 = default(Vector3);
                Vector3 rVect2 = default(Vector3);

                int x1, y1;
                int[] tX = new int[4];
                int[] tY = new int[4];
                int MinX = -1;
                int MaxX = -1;
                int MinY = -1;
                int MaxY = -1;
                int xDiff = -1;
                int yDiff = -1;
                float p1 = 0f;
                float p2 = 0f;
                bool bXBad = false;
                bool bYBad = false;
                for (int i = 0; i < (tCount - 1); i++)
                {
                    bXBad = false;
                    bYBad = false;
                    p1 = tSpline.TranslateInverseParamToFloat(tSpline.RoadDefKeysArray[i]);
                    p2 = tSpline.TranslateInverseParamToFloat(tSpline.RoadDefKeysArray[i + 1]);

                    //Skip bridges:
                    if (bSkipBridge)
                    {
                        if (tSpline.IsInBridgeTerrain(p1))
                        {
                            continue;
                        }
                    }

                    //Skip tunnels:
                    if (bSkipTunnel)
                    {
                        if (tSpline.IsInTunnelTerrain(p1))
                        {
                            continue;
                        }
                    }

                    tSpline.GetSplineValue_Both(p1, out tVect, out POS1);
                    tSpline.GetSplineValue_Both(p2, out tVect2, out POS2);
                    lVect1 = (tVect + new Vector3(SplatWidth * -POS1.normalized.z, 0, SplatWidth * POS1.normalized.x));
                    rVect1 = (tVect + new Vector3(SplatWidth * POS1.normalized.z, 0, SplatWidth * -POS1.normalized.x));
                    lVect2 = (tVect2 + new Vector3(SplatWidth * -POS2.normalized.z, 0, SplatWidth * POS2.normalized.x));
                    rVect2 = (tVect2 + new Vector3(SplatWidth * POS2.normalized.z, 0, SplatWidth * -POS2.normalized.x));

                    TranslateWorldVectToCustom(tWidth, tHeight, lVect1, ref tPos, ref tSize, out x1, out y1);
                    tX[0] = x1;
                    tY[0] = y1;
                    TranslateWorldVectToCustom(tWidth, tHeight, rVect1, ref tPos, ref tSize, out x1, out y1);
                    tX[1] = x1;
                    tY[1] = y1;
                    TranslateWorldVectToCustom(tWidth, tHeight, lVect2, ref tPos, ref tSize, out x1, out y1);
                    tX[2] = x1;
                    tY[2] = y1;
                    TranslateWorldVectToCustom(tWidth, tHeight, rVect2, ref tPos, ref tSize, out x1, out y1);
                    tX[3] = x1;
                    tY[3] = y1;

                    MinX = Mathf.Min(tX);
                    MaxX = Mathf.Max(tX);
                    MinY = Mathf.Min(tY);
                    MaxY = Mathf.Max(tY);


                    if (MinX < 0)
                    { MinX = 0; bXBad = true; }
                    if (MaxX < 0)
                    { MaxX = 0; bXBad = true; }
                    if (MinY < 0)
                    { MinY = 0; bYBad = true; }
                    if (MaxY < 0)
                    { MaxY = 0; bYBad = true; }

                    if (MinX > (tWidth - 1))
                    { MinX = (tWidth - 1); bXBad = true; }
                    if (MaxX > (tWidth - 1))
                    { MaxX = (tWidth - 1); bXBad = true; }
                    if (MinY > (tHeight - 1))
                    { MinY = (tHeight - 1); bYBad = true; }
                    if (MaxY > (tHeight - 1))
                    { MaxY = (tHeight - 1); bYBad = true; }

                    if (bXBad && bYBad)
                    { continue; }

                    xDiff = MaxX - MinX;
                    yDiff = MaxY - MinY;

                    Color[] tColors = new Color[xDiff * yDiff];
                    int cCount = tColors.Length;
                    for (int j = 0; j < cCount; j++)
                    {
                        tColors[j] = tFG;
                    }

                    if (xDiff > 0 && yDiff > 0)
                    {
                        tTexture.SetPixels(MinX, MinY, xDiff, yDiff, tColors);
                    }
                }
            }

            tTexture.Apply();
            byte[] tBytes = tTexture.EncodeToPNG();
            Object.DestroyImmediate(tTexture);
            return tBytes;
        }


        private static void TranslateWorldVectToCustom(int tWidth, int tHeight, Vector3 tVect, ref Vector3 tPos, ref Vector3 tSize, out int x1, out int y1)
        {
            //Get the normalized position of this game object relative to the terrain:
            tVect -= tPos;

            tVect.x = tVect.x / tSize.x;
            tVect.z = tVect.z / tSize.z;

            //Get the position of the terrain heightmap where this game object is:
            x1 = (int) (tVect.x * tWidth);
            y1 = (int) (tVect.z * tHeight);
        }
        #endregion


        #region "Wizard objects"
        public class WizardObject
        {
            public Texture2D Thumb;
            public string ThumbString;
            public string DisplayName;
            public string Desc;
            public bool bIsDefault;
            public bool bIsBridge;
            public string FileName;
            public string FullPath;
            public int sortID = 0;


            public string ConvertToString()
            {
                WizardObjectLibrary WOL = new WizardObjectLibrary();
                WOL.LoadFrom(this);
                return GSDRootUtil.GetString<WizardObjectLibrary>(WOL);
            }


            public void LoadDataFromWOL(WizardObjectLibrary WOL)
            {
                ThumbString = WOL.ThumbString;
                DisplayName = WOL.DisplayName;
                Desc = WOL.Desc;
                bIsDefault = WOL.bIsDefault;
                FileName = WOL.FileName;
                bIsBridge = WOL.bIsBridge;
            }


            public static WizardObject LoadFromLibrary(string tPath)
            {
#if UNITY_WEBPLAYER
				return null;
#else
                string tData = System.IO.File.ReadAllText(tPath);
                string[] tSep = new string[2];
                tSep[0] = FileSepString;
                tSep[1] = FileSepStringCRLF;
                string[] tSplit = tData.Split(tSep, System.StringSplitOptions.RemoveEmptyEntries);
                int tSplitCount = tSplit.Length;
                WizardObjectLibrary WOL = null;
                for (int i = 0; i < tSplitCount; i++)
                {
                    WOL = WizardObject.WizardObjectLibrary.WOLFromData(tSplit[i]);
                    if (WOL != null)
                    {
                        WizardObject WO = new WizardObject();
                        WO.LoadDataFromWOL(WOL);
                        return WO;
                    }
                }
                return null;
#endif
            }


            [System.Serializable]
            public class WizardObjectLibrary
            {
                public string ThumbString;
                public string DisplayName;
                public string Desc;
                public bool bIsDefault;
                public bool bIsBridge;
                public string FileName;


                public void LoadFrom(WizardObject WO)
                {
                    ThumbString = WO.ThumbString;
                    DisplayName = WO.DisplayName;
                    Desc = WO.Desc;
                    bIsDefault = WO.bIsDefault;
                    FileName = WO.FileName;
                    bIsBridge = WO.bIsBridge;
                }


                public static WizardObjectLibrary WOLFromData(string tData)
                {
                    try
                    {
                        WizardObjectLibrary WOL = (WizardObjectLibrary) GSDRootUtil.LoadData<WizardObjectLibrary>(ref tData);
                        return WOL;
                    }
                    catch
                    {
                        return null;
                    }
                }
            }
        }
        #endregion
    }


    public static class GSDIntersectionObjects
    {
        public static void CleanupIntersectionObjects(GameObject MasterGameObj)
        {
            int mCount = MasterGameObj.transform.childCount;
            if (mCount == 0)
            {
                return;
            }
            List<GameObject> tObjtoDelete = new List<GameObject>();
            for (int index = 0; index < mCount; index++)
            {
                if (MasterGameObj.transform.GetChild(index).name.ToLower().Contains("stopsign"))
                {
                    tObjtoDelete.Add(MasterGameObj.transform.GetChild(index).gameObject);
                }
                if (MasterGameObj.transform.GetChild(index).name.ToLower().Contains("trafficlight"))
                {
                    tObjtoDelete.Add(MasterGameObj.transform.GetChild(index).gameObject);
                }
            }
            for (int index = (tObjtoDelete.Count - 1); index >= 0; index--)
            {
                Object.DestroyImmediate(tObjtoDelete[index]);
            }
        }


        #region "Stop Sign All Way"
        public static void CreateStopSignsAllWay(GameObject MasterGameObj, bool bIsRB = true)
        {
            CreateStopSignsAllWay_Do(ref MasterGameObj, bIsRB);
        }


        private static void T_FixSigns(GameObject tObj)
        {
            Rigidbody rigidbody = tObj.GetComponent<Rigidbody>();
            rigidbody.useGravity = false;
            rigidbody.isKinematic = true;
        }


        private static void CreateStopSignsAllWay_Do(ref GameObject MasterGameObj, bool bIsRB)
        {
            Object prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDSignStopAllway.prefab", typeof(GameObject));

            GSDRoadIntersection GSDRI = MasterGameObj.GetComponent<GSDRoadIntersection>();
            GSDSplineC tSpline = GSDRI.Node1.GSDSpline;

            GameObject tObj = null;
            //			Vector3 xDir = default(Vector3);
            Vector3 tDir = default(Vector3);
            //			float RoadWidth = tSpline.tRoad.RoadWidth();
            //			float LaneWidth = tSpline.tRoad.opt_LaneWidth;
            float ShoulderWidth = tSpline.tRoad.opt_ShoulderWidth;

            //Cleanup:
            CleanupIntersectionObjects(MasterGameObj);

            float Mass = 100f;

            //Get four points:
            float DistFromCorner = (ShoulderWidth * 0.45f);
            Vector3 tPosRR = default(Vector3);
            Vector3 tPosRL = default(Vector3);
            Vector3 tPosLR = default(Vector3);
            Vector3 tPosLL = default(Vector3);
            GetFourPoints(GSDRI, out tPosRR, out tPosRL, out tPosLL, out tPosLR, DistFromCorner);

            //RR:
            tSpline = GSDRI.Node1.GSDSpline;
            tObj = Object.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
            //			xDir = (GSDRI.CornerRR - GSDRI.transform.position).normalized;
            tDir = StopSign_GetRot_RR(GSDRI, tSpline);
            tObj.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(0f, 180f, 0f);
            if (bIsRB)
            {
                Rigidbody RB = tObj.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = new Vector3(0f, -10f, 0f);
            }
            tObj.transform.parent = MasterGameObj.transform;
            tObj.transform.position = tPosRR;
            tObj.name = "StopSignRR";
            T_FixSigns(tObj);
            if (GSDRI.IgnoreCorner == 0)
            {
                Object.DestroyImmediate(tObj);
            }

            //LL:
            tSpline = GSDRI.Node1.GSDSpline;
            tObj = Object.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
            //			xDir = (GSDRI.CornerLL - GSDRI.transform.position).normalized;
            tDir = StopSign_GetRot_LL(GSDRI, tSpline);
            tObj.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(0f, 180f, 0f);
            if (bIsRB)
            {
                Rigidbody RB = tObj.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = new Vector3(0f, -10f, 0f);
            }
            tObj.transform.parent = MasterGameObj.transform;
            tObj.transform.position = tPosLL;
            tObj.name = "StopSignLL";
            T_FixSigns(tObj);
            if (GSDRI.IgnoreCorner == 2)
            {
                Object.DestroyImmediate(tObj);
            }

            //RL:
            tSpline = GSDRI.Node2.GSDSpline;
            tObj = Object.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
            //			xDir = (GSDRI.CornerRL - GSDRI.transform.position).normalized;
            tDir = StopSign_GetRot_RL(GSDRI, tSpline);
            tObj.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(0f, 180f, 0f);
            if (bIsRB)
            {
                Rigidbody RB = tObj.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = new Vector3(0f, -10f, 0f);
            }
            tObj.transform.parent = MasterGameObj.transform;
            tObj.transform.position = tPosRL;
            tObj.name = "StopSignRL";
            T_FixSigns(tObj);
            if (GSDRI.IgnoreCorner == 1)
            {
                Object.DestroyImmediate(tObj);
            }

            //LR:
            tSpline = GSDRI.Node2.GSDSpline;
            tObj = Object.Instantiate(prefab, Vector3.zero, Quaternion.identity) as GameObject;
            //			xDir = (GSDRI.CornerLR - GSDRI.transform.position).normalized;
            tDir = StopSign_GetRot_LR(GSDRI, tSpline);
            tObj.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(0f, 180f, 0f);
            if (bIsRB)
            {
                Rigidbody RB = tObj.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = new Vector3(0f, -10f, 0f);
            }
            tObj.transform.parent = MasterGameObj.transform;
            tObj.transform.position = tPosLR;
            tObj.name = "StopSignLR";
            T_FixSigns(tObj);
            if (GSDRI.IgnoreCorner == 3)
            {
                Object.DestroyImmediate(tObj);
            }
        }


        private static Vector3 StopSign_GetRot_RR(GSDRoadIntersection GSDRI, GSDSplineC tSpline)
        {
            float tDist = ((Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerRR) / 2f) + (0.025f * Vector3.Distance(GSDRI.CornerLL, GSDRI.CornerRR))) / tSpline.distance;
            float p = Mathf.Clamp(GSDRI.Node1.tTime - tDist, 0f, 1f);
            Vector3 POS = tSpline.GetSplineValue(p, true);
            return (POS * -1);
        }


        private static Vector3 StopSign_GetRot_LL(GSDRoadIntersection GSDRI, GSDSplineC tSpline)
        {
            float tDist = ((Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerLL) / 2f) + (0.025f * Vector3.Distance(GSDRI.CornerLL, GSDRI.CornerRR))) / tSpline.distance;
            float p = Mathf.Clamp(GSDRI.Node1.tTime + tDist, 0f, 1f);
            Vector3 POS = tSpline.GetSplineValue(p, true);
            return POS;
        }


        private static Vector3 StopSign_GetRot_RL(GSDRoadIntersection GSDRI, GSDSplineC tSpline)
        {
            float tDist = ((Vector3.Distance(GSDRI.CornerLL, GSDRI.CornerRL) / 2f) + (0.025f * Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerRL))) / tSpline.distance;
            float p = -1f;
            if (GSDRI.bFlipped)
            {
                p = Mathf.Clamp(GSDRI.Node2.tTime - tDist, 0f, 1f);
            }
            else
            {
                p = Mathf.Clamp(GSDRI.Node2.tTime + tDist, 0f, 1f);
            }
            Vector3 POS = tSpline.GetSplineValue(p, true);
            //POS = Vector3.Cross(POS,Vector3.up);
            if (GSDRI.bFlipped)
            {
                return (POS * -1);
            }
            else
            {
                return POS;
            }
        }


        private static Vector3 StopSign_GetRot_LR(GSDRoadIntersection GSDRI, GSDSplineC tSpline)
        {
            float tDist = ((Vector3.Distance(GSDRI.CornerRR, GSDRI.CornerLR) / 2f) + (0.025f * Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerRL))) / tSpline.distance;
            float p = -1f;
            if (GSDRI.bFlipped)
            {
                p = Mathf.Clamp(GSDRI.Node2.tTime + tDist, 0f, 1f);
            }
            else
            {
                p = Mathf.Clamp(GSDRI.Node2.tTime - tDist, 0f, 1f);
            }
            Vector3 POS = tSpline.GetSplineValue(p, true);
            //POS = Vector3.Cross(POS,Vector3.up);
            if (GSDRI.bFlipped)
            {
                return POS;
            }
            else
            {
                return (POS * -1);
            }
        }
        #endregion


        #region "Traffic light bases"
        public static void CreateTrafficLightBases(GameObject MasterGameObj, bool bIsTrafficLight1 = true)
        {
            CreateTrafficLightBases_Do(ref MasterGameObj, bIsTrafficLight1);
        }


        private static void CreateTrafficLightBases_Do(ref GameObject MasterGameObj, bool bIsTrafficLight1)
        {
            GSDRoadIntersection GSDRI = MasterGameObj.GetComponent<GSDRoadIntersection>();
            GSDSplineC tSpline = GSDRI.Node1.GSDSpline;
            bool bIsRB = true;

            //			float RoadWidth = tSpline.tRoad.RoadWidth();
            float LaneWidth = tSpline.tRoad.opt_LaneWidth;
            float ShoulderWidth = tSpline.tRoad.opt_ShoulderWidth;

            int Lanes = tSpline.tRoad.opt_Lanes;
            int LanesHalf = Lanes / 2;
            float LanesForInter = -1;
            if (GSDRI.rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
            {
                LanesForInter = LanesHalf + 1f;
            }
            else if (GSDRI.rType == GSDRoadIntersection.RoadTypeEnum.TurnLane)
            {
                LanesForInter = LanesHalf + 1f;
            }
            else
            {
                LanesForInter = LanesHalf - 1 + 1f;
            }
            float DistFromCorner = (ShoulderWidth * 0.45f);
            float TLDistance = (LanesForInter * LaneWidth) + DistFromCorner;

            GameObject tObjRR = null;
            GameObject tObjRL = null;
            GameObject tObjLL = null;
            GameObject tObjLR = null;
            //			Vector3 xDir = default(Vector3);
            Vector3 tDir = default(Vector3);
            float Mass = 12500f;
            Vector3 COM = new Vector3(0f, 0f, 4f);
            Vector3 zeroVect = new Vector3(0f, 0f, 0f);
            Vector3 StartVec = default(Vector3);
            Vector3 EndVec = default(Vector3);
            //			bool bContains = false;
            //			MeshFilter MF = null;
            //			Vector3[] tVerts = null;
            Rigidbody RB = null;

            //Get four points:
            Vector3 tPosRR = default(Vector3);
            Vector3 tPosRL = default(Vector3);
            Vector3 tPosLR = default(Vector3);
            Vector3 tPosLL = default(Vector3);
            GetFourPoints(GSDRI, out tPosRR, out tPosRL, out tPosLL, out tPosLR, DistFromCorner);

            //Cleanup:
            CleanupIntersectionObjects(MasterGameObj);

            float[] tempDistances = new float[4];
            tempDistances[0] = Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerLL);
            tempDistances[1] = Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerRR);
            tempDistances[2] = Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerLL);
            tempDistances[3] = Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerRR);
            float MaxDistanceStart = Mathf.Max(tempDistances);
            bool OrigPoleAlignment = GSDRI.bRegularPoleAlignment;

            //Node1:
            //RL:
            tObjRL = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
            //			xDir = (GSDRI.CornerRL - GSDRI.transform.position).normalized;
            tDir = TrafficLightBase_GetRot_RL(GSDRI, tSpline, DistFromCorner);
            if (tDir == zeroVect)
            {
                tDir = new Vector3(0f, 0.0001f, 0f);
            }
            tObjRL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
            tObjRL.transform.parent = MasterGameObj.transform;
            StartVec = tPosRL;
            EndVec = (tDir.normalized * TLDistance) + StartVec;
            if (!GSDRI.bRegularPoleAlignment && GSDRI.ContainsLine(StartVec, EndVec))
            { //Convert to regular alignment if necessary
                tObjRL.transform.parent = null;
                tDir = TrafficLightBase_GetRot_RL(GSDRI, tSpline, DistFromCorner, true);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjRL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjRL.transform.parent = MasterGameObj.transform;
            }
            else
            {
                GSDRI.bRegularPoleAlignment = true;
                if (tObjRL != null)
                {
                    Object.DestroyImmediate(tObjRL);
                }
                tObjRL = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
                //				xDir = (GSDRI.CornerRL - GSDRI.transform.position).normalized;
                tDir = TrafficLightBase_GetRot_RL(GSDRI, tSpline, DistFromCorner);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjRL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjRL.transform.parent = MasterGameObj.transform;
                StartVec = tPosRL;
                EndVec = (tDir.normalized * TLDistance) + StartVec;
                GSDRI.bRegularPoleAlignment = OrigPoleAlignment;
            }
            if (bIsRB)
            {
                RB = tObjRL.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = COM;
                tObjRL.AddComponent<GSDRigidBody>();
            }
            tObjRL.transform.position = tPosRL;
            tObjRL.transform.name = "TrafficLightRL";
            //LR:
            tObjLR = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
            //			xDir = (GSDRI.CornerLR - GSDRI.transform.position).normalized;
            tDir = TrafficLightBase_GetRot_LR(GSDRI, tSpline, DistFromCorner);
            if (tDir == zeroVect)
            {
                tDir = new Vector3(0f, 0.0001f, 0f);
            }
            tObjLR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
            tObjLR.transform.parent = MasterGameObj.transform;
            StartVec = tPosLR;
            EndVec = (tDir.normalized * TLDistance) + StartVec;
            if (!GSDRI.bRegularPoleAlignment && GSDRI.ContainsLine(StartVec, EndVec))
            { //Convert to regular alignment if necessary
                tObjLR.transform.parent = null;
                tDir = TrafficLightBase_GetRot_LR(GSDRI, tSpline, DistFromCorner, true);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjLR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjLR.transform.parent = MasterGameObj.transform;
            }
            else
            {
                GSDRI.bRegularPoleAlignment = true;
                if (tObjLR != null)
                {
                    Object.DestroyImmediate(tObjLR);
                }
                tObjLR = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
                //				xDir = (GSDRI.CornerLR - GSDRI.transform.position).normalized;
                tDir = TrafficLightBase_GetRot_LR(GSDRI, tSpline, DistFromCorner);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjLR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjLR.transform.parent = MasterGameObj.transform;
                StartVec = tPosLR;
                EndVec = (tDir.normalized * TLDistance) + StartVec;
                GSDRI.bRegularPoleAlignment = OrigPoleAlignment;
            }
            if (bIsRB)
            {
                RB = tObjLR.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = COM;
                tObjLR.AddComponent<GSDRigidBody>();
            }
            tObjLR.transform.position = tPosLR;
            tObjLR.transform.name = "TrafficLightLR";
            //Node2:
            //RR:
            tObjRR = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
            //			xDir = (GSDRI.CornerRR - GSDRI.transform.position).normalized;
            tDir = TrafficLightBase_GetRot_RR(GSDRI, tSpline, DistFromCorner);
            if (tDir == zeroVect)
            {
                tDir = new Vector3(0f, 0.0001f, 0f);
            }
            tObjRR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
            tObjRR.transform.parent = MasterGameObj.transform;
            StartVec = tPosRR;
            EndVec = (tDir.normalized * TLDistance) + StartVec;
            if (!GSDRI.bRegularPoleAlignment && GSDRI.ContainsLine(StartVec, EndVec))
            { //Convert to regular alignment if necessary
                tObjRR.transform.parent = null;
                tDir = TrafficLightBase_GetRot_RR(GSDRI, tSpline, DistFromCorner, true);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjRR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, 0f, 0f);
                tObjRR.transform.parent = MasterGameObj.transform;
            }
            else
            {
                GSDRI.bRegularPoleAlignment = true;
                if (tObjRR != null)
                { Object.DestroyImmediate(tObjRR); }
                tObjRR = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
                //				xDir = (GSDRI.CornerRR - GSDRI.transform.position).normalized;
                tDir = TrafficLightBase_GetRot_RR(GSDRI, tSpline, DistFromCorner);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjRR.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjRR.transform.parent = MasterGameObj.transform;
                StartVec = tPosRR;
                EndVec = (tDir.normalized * TLDistance) + StartVec;
                GSDRI.bRegularPoleAlignment = OrigPoleAlignment;
            }
            if (bIsRB)
            {
                RB = tObjRR.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = COM;
                tObjRR.AddComponent<GSDRigidBody>();
            }
            tObjRR.transform.position = tPosRR;
            tObjRR.transform.name = "TrafficLightRR";

            //LL:
            tObjLL = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
            //			xDir = (GSDRI.CornerLL - GSDRI.transform.position).normalized;
            tDir = TrafficLightBase_GetRot_LL(GSDRI, tSpline, DistFromCorner);
            if (tDir == zeroVect)
            {
                tDir = new Vector3(0f, 0.0001f, 0f);
            }
            tObjLL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
            tObjLL.transform.parent = MasterGameObj.transform;
            StartVec = tPosLL;
            EndVec = (tDir.normalized * TLDistance) + StartVec;
            if (!GSDRI.bRegularPoleAlignment && GSDRI.ContainsLine(StartVec, EndVec))
            { //Convert to regular alignment if necessary
                tObjLL.transform.parent = null;
                tDir = TrafficLightBase_GetRot_LL(GSDRI, tSpline, DistFromCorner, true);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjLL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, 0f, 0f);
                tObjLL.transform.parent = MasterGameObj.transform;
            }
            else
            {
                GSDRI.bRegularPoleAlignment = true;
                if (tObjLL != null)
                {
                    Object.DestroyImmediate(tObjLL);
                }
                tObjLL = CreateTrafficLight(TLDistance, true, true, MaxDistanceStart, GSDRI.bTrafficPoleStreetLight, tSpline.tRoad.GSDRS.opt_bSaveMeshes);
                //				xDir = (GSDRI.CornerLL - GSDRI.transform.position).normalized;
                tDir = TrafficLightBase_GetRot_LL(GSDRI, tSpline, DistFromCorner);
                if (tDir == zeroVect)
                {
                    tDir = new Vector3(0f, 0.0001f, 0f);
                }
                tObjLL.transform.rotation = Quaternion.LookRotation(tDir) * Quaternion.Euler(-90f, -180f, 0f);
                tObjLL.transform.parent = MasterGameObj.transform;
                StartVec = tPosLL;
                EndVec = (tDir.normalized * TLDistance) + StartVec;
                GSDRI.bRegularPoleAlignment = OrigPoleAlignment;
            }
            if (bIsRB)
            {
                RB = tObjLL.AddComponent<Rigidbody>();
                RB.mass = Mass;
                RB.centerOfMass = COM;
                tObjLL.AddComponent<GSDRigidBody>();
            }
            tObjLL.transform.position = tPosLL;
            tObjLL.transform.name = "TrafficLightLL";

            //Create the actual lights:
            CreateTrafficLightMains(MasterGameObj, tObjRR, tObjRL, tObjLL, tObjLR);
        }


        private static bool CreateTrafficLightBase_IsInIntersection(GSDRoadIntersection GSDRI, ref Vector3 StartVec, ref Vector3 EndVec)
        {
            return GSDRI.ContainsLine(StartVec, EndVec);
        }


        private static GameObject CreateTrafficLight(float tDistance, bool bIsTrafficLight1, bool bOptionalCollider, float xDistance, bool bLight, bool bSaveAsset)
        {
            GameObject tObj = null;
            string tTrafficLightNumber = "1";
            if (!bIsTrafficLight1)
            {
                tTrafficLightNumber = "2";
            }

            bool bDoCustom = false;
            xDistance = Mathf.Ceil(xDistance);  //Round up to nearest whole F
            tDistance = Mathf.Ceil(tDistance);  //Round up to nearest whole F
                                                //			string assetName = "GSDInterTLB" + tTrafficLightNumber + "_" + tDistance.ToString("F0") + "_" + xDistance.ToString("F0") + ".prefab";
            string assetNameAsset = "GSDInterTLB" + tTrafficLightNumber + "_" + tDistance.ToString("F0") + "_" + xDistance.ToString("F0") + ".asset";
            string BackupFBX = "GSDInterTLB" + tTrafficLightNumber + ".FBX";
            float tMod = tDistance / 5f;
            float hMod = (tDistance / 10f) * 0.7f;
            float xMod = ((xDistance / 20f) + 2f) * 0.3334f;
            xMod = Mathf.Clamp(xMod, 1f, 20f);
            tMod = Mathf.Clamp(tMod, 1f, 20f);
            hMod = Mathf.Clamp(hMod, 1f, 20f);

            bool bXMod = false;
            if (!GSDRootUtil.IsApproximately(xMod, 1f, 0.0001f))
            {
                bXMod = true;
            }

            Mesh xMesh = (Mesh) UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/TrafficLightBases/" + assetNameAsset, typeof(Mesh));
            if (xMesh == null)
            {
                xMesh = (Mesh) UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/TrafficLightBases/" + BackupFBX, typeof(Mesh));
                bDoCustom = true;
            }

            tObj = new GameObject("TempTrafficLight");
            MeshFilter MF = tObj.GetComponent<MeshFilter>();
            if (MF == null)
            {
                MF = tObj.AddComponent<MeshFilter>();
            }
            MeshRenderer MR = tObj.GetComponent<MeshRenderer>();
            if (MR == null)
            {
                MR = tObj.AddComponent<MeshRenderer>();
            }
            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/Signs/GSDInterTLB" + tTrafficLightNumber + ".mat", MR);

            if (!bDoCustom)
            {
                MF.sharedMesh = xMesh;
            }

            float tempMaxHeight = 7.6f * hMod;
            float xValue = tempMaxHeight - 7.6f;
            if (bDoCustom)
            {
                Mesh tMesh = new Mesh();
                tMesh.vertices = xMesh.vertices;
                tMesh.triangles = xMesh.triangles;
                tMesh.uv = xMesh.uv;
                tMesh.normals = xMesh.normals;
                tMesh.tangents = xMesh.tangents;
                MF.sharedMesh = tMesh;
                Vector3[] tVerts = tMesh.vertices;

                xValue = (xMod * 6f) - 6f;
                if ((xMod * 6f) > (tempMaxHeight - 1f))
                {
                    xValue = (tempMaxHeight - 1f) - 6f;
                }

                //				float tValue = 0f;
                //				float hValue = 0f;
                bool bIgnoreMe = false;


                int mCount = tVerts.Length;
                Vector2[] uv = tMesh.uv;
                //				List<int> tUVInts = new List<int>();
                for (int index = 0; index < mCount; index++)
                {
                    bIgnoreMe = false;
                    if (GSDRootUtil.IsApproximately(tVerts[index].y, 5f, 0.01f))
                    {
                        tVerts[index].y = tDistance;
                        if (uv[index].y > 3.5f)
                        {
                            uv[index].y *= tMod;
                        }
                        bIgnoreMe = true;
                    }
                    if (!bIgnoreMe && tVerts[index].z > 7.5f)
                    {
                        tVerts[index].z *= hMod;
                        if (uv[index].y > 3.8f)
                        {
                            uv[index].y *= hMod;
                        }
                    }

                    if (bXMod && tVerts[index].z > 4.8f && tVerts[index].z < 6.2f)
                    {
                        tVerts[index].z += xValue;
                    }
                }
                tMesh.vertices = tVerts;
                tMesh.uv = uv;
                tMesh.RecalculateNormals();
                tMesh.RecalculateBounds();

                //Save:
                if (bSaveAsset)
                {
                    UnityEditor.AssetDatabase.CreateAsset(tMesh, GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/TrafficLightBases/" + assetNameAsset);
                }
            }

            BoxCollider BC = tObj.AddComponent<BoxCollider>();
            float MaxHeight = MF.sharedMesh.bounds.extents.z * 2;
            BC.size = new Vector3(0.35f, 0.35f, MaxHeight);
            BC.center = new Vector3(0f, 0f, (MaxHeight / 2f));

            if (bOptionalCollider)
            {
                float MaxWidth = MF.sharedMesh.bounds.extents.y;
                GameObject tObjCollider = new GameObject("col2");
                BC = tObjCollider.AddComponent<BoxCollider>();
                BC.size = new Vector3(0.175f, MaxWidth, 0.175f);
                BC.center = new Vector3(0f, MaxWidth / 2f, 5.808f);
                tObjCollider.transform.parent = tObj.transform;
            }

            if (bLight)
            {
                GameObject yObj = (GameObject) UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDStreetLight_TrafficLight.prefab", typeof(GameObject));
                GameObject kObj = (GameObject) GameObject.Instantiate(yObj);
                kObj.transform.position = tObj.transform.position;
                kObj.transform.position += new Vector3(0f, 0f, MaxHeight - 7.6f);
                kObj.transform.parent = tObj.transform;
                kObj.transform.rotation = Quaternion.identity;
                //				kObj.name = "StreetLight";
            }


            //Bounds calcs:
            MeshFilter[] tMeshes = tObj.GetComponents<MeshFilter>();
            for (int index = 0; index < tMeshes.Length; index++)
            {
                tMeshes[index].sharedMesh.RecalculateBounds();
            }

            return tObj;
        }


        private static Vector3 TrafficLightBase_GetRot_RL(GSDRoadIntersection GSDRI, GSDSplineC tSpline, float DistFromCorner, bool bOverrideRegular = false)
        {
            Vector3 POS = default(Vector3);
            if (!GSDRI.bRegularPoleAlignment && !bOverrideRegular)
            {
                //				float tDist = ((Vector3.Distance(GSDRI.CornerRR,GSDRI.CornerRL) / 2f) + DistFromCorner) / tSpline.distance;;
                float p = Mathf.Clamp(GSDRI.Node1.tTime, 0f, 1f);
                POS = tSpline.GetSplineValue(p, true);
                POS = Vector3.Cross(POS, Vector3.up);
                return POS;
            }
            else
            {
                POS = GSDRI.CornerRL - GSDRI.CornerLL;
                return POS * -1;
            }
        }


        private static Vector3 TrafficLightBase_GetRot_LR(GSDRoadIntersection GSDRI, GSDSplineC tSpline, float DistFromCorner, bool bOverrideRegular = false)
        {
            Vector3 POS = default(Vector3);
            if (!GSDRI.bRegularPoleAlignment && !bOverrideRegular)
            {
                //				float tDist = ((Vector3.Distance(GSDRI.CornerLR,GSDRI.CornerLL) / 2f) + DistFromCorner) / tSpline.distance;;
                float p = Mathf.Clamp(GSDRI.Node1.tTime, 0f, 1f);
                POS = tSpline.GetSplineValue(p, true);
                POS = Vector3.Cross(POS, Vector3.up);
                return POS * -1;
            }
            else
            {
                POS = GSDRI.CornerRR - GSDRI.CornerLR;
                return POS;
            }
        }


        private static Vector3 TrafficLightBase_GetRot_RR(GSDRoadIntersection GSDRI, GSDSplineC tSpline, float DistFromCorner, bool bOverrideRegular = false)
        {
            Vector3 POS = default(Vector3);
            if (!GSDRI.bRegularPoleAlignment && !bOverrideRegular)
            {
                //				float tDist = ((Vector3.Distance(GSDRI.CornerRR,GSDRI.CornerLR) / 2f) + DistFromCorner) / tSpline.distance;;
                float p = Mathf.Clamp(GSDRI.Node2.tTime, 0f, 1f);
                POS = tSpline.GetSplineValue(p, true);
                POS = Vector3.Cross(POS, Vector3.up);
                if (GSDRI.bFlipped)
                {
                    POS = POS * -1;
                }
            }
            else
            {
                POS = GSDRI.CornerLL - GSDRI.CornerLR;
            }
            return POS;
        }


        private static Vector3 TrafficLightBase_GetRot_LL(GSDRoadIntersection GSDRI, GSDSplineC tSpline, float DistFromCorner, bool bOverrideRegular = false)
        {
            Vector3 POS = default(Vector3);
            if (!GSDRI.bRegularPoleAlignment && !bOverrideRegular)
            {
                //				float tDist = ((Vector3.Distance(GSDRI.CornerLL,GSDRI.CornerRL) / 2f) + DistFromCorner) / tSpline.distance;;
                float p = Mathf.Clamp(GSDRI.Node2.tTime, 0f, 1f);
                POS = tSpline.GetSplineValue(p, true);
                POS = Vector3.Cross(POS, Vector3.up);
                if (GSDRI.bFlipped)
                {
                    POS = POS * -1;
                }
            }
            else
            {
                POS = GSDRI.CornerRL - GSDRI.CornerRR;
            }
            return POS * -1;
        }
        #endregion


        #region "Traffic light mains"
        private static void CreateTrafficLightMains(GameObject MasterGameObj, GameObject tRR, GameObject tRL, GameObject tLL, GameObject tLR)
        {
            GSDRoadIntersection GSDRI = MasterGameObj.GetComponent<GSDRoadIntersection>();
            GSDSplineC tSpline = GSDRI.Node1.GSDSpline;

            float tDist = (Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerRR) / 2f) / tSpline.distance;
            Vector3 tan = tSpline.GetSplineValue(GSDRI.Node1.tTime + tDist, true);
            ProcessPole(MasterGameObj, tRL, tan * -1, 1, Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerRR));
            tDist = (Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerLL) / 2f) / tSpline.distance;
            tan = tSpline.GetSplineValue(GSDRI.Node1.tTime - tDist, true);
            ProcessPole(MasterGameObj, tLR, tan, 3, Vector3.Distance(GSDRI.CornerLR, GSDRI.CornerLL));


            float InterDist = Vector3.Distance(GSDRI.CornerRL, GSDRI.CornerLL);
            tDist = (InterDist / 2f) / tSpline.distance;
            tan = tSpline.GetSplineValue(GSDRI.Node1.tTime + tDist, true);

            float fTime1 = GSDRI.Node2.tTime + tDist;
            float fTime2neg = GSDRI.Node2.tTime - tDist;

            tSpline = GSDRI.Node2.GSDSpline;
            if (GSDRI.bFlipped)
            {
                tan = tSpline.GetSplineValue(fTime1, true);
                ProcessPole(MasterGameObj, tRR, tan, 0, InterDist);
                tan = tSpline.GetSplineValue(fTime2neg, true);
                ProcessPole(MasterGameObj, tLL, tan * -1, 2, InterDist);
            }
            else
            {
                tan = tSpline.GetSplineValue(fTime2neg, true);
                ProcessPole(MasterGameObj, tRR, tan * -1, 0, InterDist);
                tan = tSpline.GetSplineValue(fTime1, true);
                ProcessPole(MasterGameObj, tLL, tan, 2, InterDist);
            }

            if (GSDRI.IgnoreCorner == 0)
            {
                if (tRR != null)
                {
                    Object.DestroyImmediate(tRR);
                }
            }
            else if (GSDRI.IgnoreCorner == 1)
            {
                if (tRL != null)
                {
                    Object.DestroyImmediate(tRL);
                }
            }
            else if (GSDRI.IgnoreCorner == 2)
            {
                if (tLL != null)
                {
                    Object.DestroyImmediate(tLL);
                }
            }
            else if (GSDRI.IgnoreCorner == 3)
            {
                if (tLR != null)
                {
                    Object.DestroyImmediate(tLR);
                }
            }
        }


        private static void AdjustLightPrefab(GameObject tLight)
        {
            foreach (Light light in tLight.GetComponentsInChildren<Light>())
            {
                if (light.type == LightType.Point)
                {
                    light.flare = UnityEditor.AssetDatabase.LoadAssetAtPath<Flare>(GSDRoadUtilityEditor.GetBasePath() + "/Flares/GSDSodiumBulb.flare");
                }
            }
        }


        private static void ProcessPole(GameObject MasterGameObj, GameObject tObj, Vector3 tan, int tCorner, float InterDist)
        {
            GSDRoadIntersection GSDRI = MasterGameObj.GetComponent<GSDRoadIntersection>();
            GSDSplineC tSpline = GSDRI.Node1.GSDSpline;
            //			bool bIsRB = true;

            //			float RoadWidth = tSpline.tRoad.RoadWidth();
            float LaneWidth = tSpline.tRoad.opt_LaneWidth;
            float ShoulderWidth = tSpline.tRoad.opt_ShoulderWidth;

            int Lanes = tSpline.tRoad.opt_Lanes;
            int LanesHalf = Lanes / 2;
            float LanesForInter = -1;
            bool tallerPole = true;
            if (GSDRI.rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
            {
                LanesForInter = LanesHalf + 1f;
            }
            else if (GSDRI.rType == GSDRoadIntersection.RoadTypeEnum.TurnLane)
            {
                LanesForInter = LanesHalf + 1f;
            }
            else
            {
                tallerPole = false;
                LanesForInter = LanesHalf;
            }
            float DistFromCorner = (ShoulderWidth * 0.35f);
            float TLDistance = (LanesForInter * LaneWidth) + DistFromCorner;

            MeshFilter MF = tObj.GetComponent<MeshFilter>();
            Mesh tMesh = MF.sharedMesh;
            Vector3[] tVerts = tMesh.vertices;

            float LightHeadZ = 6f;
            if (tallerPole)
                LightHeadZ = 7.1f;
            Vector3 StartVec = new Vector3(0f, 0.5f, LightHeadZ);
            Vector3 EndVec = new Vector3(0f, tMesh.bounds.extents.y * 2, LightHeadZ);

            
            StartVec = (((EndVec - StartVec) * (DistFromCorner / TLDistance)) + StartVec);
            Vector3 tempR_Start = tVerts[399];
            Vector3 tempR_End = tVerts[396];
            Vector3 tLanePosR = StartVec - new Vector3(0f, 1.6f, 0.5f);
            tLanePosR.z -= 1f;

            float SmallerDist = Vector3.Distance(StartVec, EndVec);

            //StartVec = Corner
            //2.5m = lane
            //7.5m = lane
            //12.5m = lane
            Vector3[] tLanePos = new Vector3[LanesHalf];
            for (int index = 0; index < LanesHalf; index++)
            {
                tLanePos[index] = (((EndVec - StartVec) * (((LaneWidth * 0.5f) + (index * LaneWidth)) / SmallerDist)) + StartVec);
            }
            Vector3 tLanePosL = default(Vector3);
            Vector3 tLanePosL_Sign = default(Vector3);

            if (GSDRI.bLeftTurnYieldOnGreen)
            {
                tLanePosL = ((EndVec - StartVec) * ((SmallerDist - 1.8f) / SmallerDist)) + StartVec;
                tLanePosL_Sign = ((EndVec - StartVec) * ((SmallerDist - 3.2f) / SmallerDist)) + StartVec;
            }
            else
            {
                tLanePosL = ((EndVec - StartVec) * ((SmallerDist - 2.5f) / SmallerDist)) + StartVec;
            }

            Vector3 tPos1 = default(Vector3);
            if (tCorner == 0)
            { //RR
                tPos1 = GSDRI.CornerLR;
            }
            else if (tCorner == 1)
            { //RL
                tPos1 = GSDRI.CornerRR;
            }
            else if (tCorner == 2)
            { //LL
                tPos1 = GSDRI.CornerRL;
            }
            else if (tCorner == 3)
            { //LR
                tPos1 = GSDRI.CornerLL;
            }

            int mCount = tLanePos.Length;
            float mDistance = -50000f;
            float tDistance = 0f;
            for (int index = 0; index < mCount; index++)
            {
                tDistance = Vector3.Distance(tObj.transform.TransformPoint(tLanePos[index]), tPos1);
                if (tDistance > mDistance)
                {
                    mDistance = tDistance;
                }
            }
            tDistance = Vector3.Distance(tObj.transform.TransformPoint(tLanePosL), tPos1);
            if (tDistance > mDistance)
            {
                mDistance = tDistance;
            }
            tDistance = Vector3.Distance(tObj.transform.TransformPoint(tLanePosR), tPos1);
            if (tDistance > mDistance)
            {
                mDistance = tDistance;
            }

            float tScaleSense = ((200f - GSDRI.ScalingSense) / 200f) * 200f;
            tScaleSense = Mathf.Clamp(tScaleSense * 0.1f, 0f, 20f);
            float ScaleMod = ((mDistance / 17f) + tScaleSense) * (1f / (tScaleSense + 1f));
            if (GSDRootUtil.IsApproximately(tScaleSense, 20f, 0.05f))
            {
                ScaleMod = 1f;
            }
            ScaleMod = Mathf.Clamp(ScaleMod, 1f, 1.5f);
            Vector3 tScale = new Vector3(ScaleMod, ScaleMod, ScaleMod);
            bool bScale = true;
            if (GSDRootUtil.IsApproximately(ScaleMod, 1f, 0.001f))
            {
                bScale = false;
            }

            //Debug.Log (mDistance + " " + ScaleMod + " " + tScaleSense);

            GameObject tRight = null;
            GameObject tLeft = null;
            GameObject tLeft_Sign = null;
            Object prefab = null;

            MeshRenderer MR_Left = null;
            MeshRenderer MR_Right = null;
            MeshRenderer[] MR_Mains = new MeshRenderer[LanesHalf];
            int cCount = -1;
            if (GSDRI.rType != GSDRoadIntersection.RoadTypeEnum.NoTurnLane)
            {
                if (GSDRI.bLeftTurnYieldOnGreen)
                {
                    prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDTrafficLightLeftYield.prefab", typeof(GameObject));
                }
                else
                {
                    prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDTrafficLightLeft.prefab", typeof(GameObject));
                }
                tLeft = (GameObject) GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                AdjustLightPrefab(tLeft);
                tLeft.transform.position = tObj.transform.TransformPoint(tLanePosL);
                tLeft.transform.rotation = Quaternion.LookRotation(tan) * Quaternion.Euler(0f, 90f, 0f);
                tLeft.transform.parent = tObj.transform;
                tLeft.transform.name = "LightLeft";

                cCount = tLeft.transform.childCount;
                for (int index = 0; index < cCount; index++)
                {
                    if (tLeft.transform.GetChild(index).name.ToLower() == "lights")
                    {
                        MR_Left = tLeft.transform.GetChild(index).GetComponent<MeshRenderer>();
                    }
                }

                if (bScale)
                { tLeft.transform.localScale = tScale; }

                if (GSDRI.bLeftTurnYieldOnGreen)
                {
                    prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDSignYieldOnGreen.prefab", typeof(GameObject));
                    tLeft_Sign = (GameObject) GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                    tLeft_Sign.transform.position = tObj.transform.TransformPoint(tLanePosL_Sign);
                    tLeft_Sign.transform.rotation = Quaternion.LookRotation(tan) * Quaternion.Euler(-90f, 90f, 0f);
                    tLeft_Sign.transform.parent = tObj.transform;
                    tLeft_Sign.transform.name = "SignYieldOnGreen";
                    if (bScale)
                    { tLeft_Sign.transform.localScale = tScale; }
                }
            }
            if (GSDRI.rType == GSDRoadIntersection.RoadTypeEnum.BothTurnLanes)
            {
                prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDTrafficLightRight.prefab", typeof(GameObject));
                tRight = (GameObject) GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                AdjustLightPrefab(tRight);
                tRight.transform.position = tObj.transform.TransformPoint(tLanePosR);
                tRight.transform.rotation = Quaternion.LookRotation(tan) * Quaternion.Euler(0f, 90f, 0f);
                tRight.transform.parent = tObj.transform;
                tRight.transform.name = "LightRight";
                if (bScale)
                {
                    tRight.transform.localScale = tScale;
                }

                cCount = tRight.transform.childCount;
                for (int index = 0; index < cCount; index++)
                {
                    if (tRight.transform.GetChild(index).name.ToLower() == "lights")
                    {
                        MR_Right = tRight.transform.GetChild(index).GetComponent<MeshRenderer>();
                    }
                }
            }
            GameObject[] tLanes = new GameObject[LanesHalf];
            for (int index = 0; index < LanesHalf; index++)
            {
                prefab = UnityEditor.AssetDatabase.LoadAssetAtPath(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/RoadObj/Signs/GSDTrafficLightMain.prefab", typeof(GameObject));
                tLanes[index] = (GameObject) GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                AdjustLightPrefab(tLanes[index]);
                tLanes[index].transform.position = tObj.transform.TransformPoint(tLanePos[index]);
                tLanes[index].transform.rotation = Quaternion.LookRotation(tan) * Quaternion.Euler(0f, 90f, 0f);
                tLanes[index].transform.parent = tObj.transform;
                tLanes[index].transform.name = "Light" + index.ToString();
                if (bScale)
                {
                    tLanes[index].transform.localScale = tScale;
                }

                cCount = tLanes[index].transform.childCount;
                for (int j = 0; j < cCount; j++)
                {
                    if (tLanes[index].transform.GetChild(j).name.ToLower() == "lights")
                    {
                        MR_Mains[index] = tLanes[index].transform.GetChild(j).GetComponent<MeshRenderer>();
                    }
                }
            }

            GSDTrafficLightController LM = new GSDTrafficLightController(ref tLeft, ref tRight, ref tLanes, ref MR_Left, ref MR_Right, ref MR_Mains);
            if (tCorner == 0)
            {
                GSDRI.LightsRR = null;
                GSDRI.LightsRR = LM;
            }
            else if (tCorner == 1)
            {
                GSDRI.LightsRL = null;
                GSDRI.LightsRL = LM;
            }
            else if (tCorner == 2)
            {
                GSDRI.LightsLL = null;
                GSDRI.LightsLL = LM;
            }
            else if (tCorner == 3)
            {
                GSDRI.LightsLR = null;
                GSDRI.LightsLR = LM;
            }
        }
        #endregion


        public static void GetFourPoints(GSDRoadIntersection GSDRI, out Vector3 tPosRR, out Vector3 tPosRL, out Vector3 tPosLL, out Vector3 tPosLR, float DistFromCorner)
        {
            GetFourPoints_Do(ref GSDRI, out tPosRR, out tPosRL, out tPosLL, out tPosLR, DistFromCorner);
        }


        private static void GetFourPoints_Do(ref GSDRoadIntersection GSDRI, out Vector3 tPosRR, out Vector3 tPosRL, out Vector3 tPosLL, out Vector3 tPosLR, float DistFromCorner)
        {
            //Get four points:
            float tPos1 = 0f;
            float tPos2 = 0f;
            Vector3 tTan1 = default(Vector3);
            Vector3 tTan2 = default(Vector3);
            float Node1Width = -1f;
            float Node2Width = -1f;
            Vector3 tVectRR = GSDRI.CornerRR;
            Vector3 tVectRL = GSDRI.CornerRL;
            Vector3 tVectLR = GSDRI.CornerLR;
            Vector3 tVectLL = GSDRI.CornerLL;
            Vector3 tDir = default(Vector3);
            float ShoulderWidth1 = GSDRI.Node1.GSDSpline.tRoad.opt_ShoulderWidth;
            float ShoulderWidth2 = GSDRI.Node2.GSDSpline.tRoad.opt_ShoulderWidth;

            if (!GSDRI.bFlipped)
            {
                //RR:
                Node1Width = (Vector3.Distance(GSDRI.CornerRR, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerRR, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime - Node1Width;
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true) * -1f;
                tPos2 = GSDRI.Node2.tTime + Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true);
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosRR = tVectRR + (tDir * DistFromCorner);
                //RL:
                Node1Width = (Vector3.Distance(GSDRI.CornerRL, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerRL, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime + Node1Width;
                if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
                {
                    tPos1 = GSDRI.Node1.tTime;
                }
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true);
                tPos2 = GSDRI.Node2.tTime + Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true);
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosRL = tVectRL + (tDir * DistFromCorner);
                //LL:
                Node1Width = (Vector3.Distance(GSDRI.CornerLL, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerLL, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime + Node1Width;
                if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
                {
                    tPos1 = GSDRI.Node1.tTime;
                }
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true);
                tPos2 = GSDRI.Node2.tTime - Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true) * -1f;
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosLL = tVectLL + (tDir * DistFromCorner);
                //LR:
                Node1Width = (Vector3.Distance(GSDRI.CornerLR, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerLR, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime - Node1Width;
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true) * -1f;
                tPos2 = GSDRI.Node2.tTime - Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true) * -1f;
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosLR = tVectLR + (tDir * DistFromCorner);
            }
            else
            {
                //RR:
                Node1Width = (Vector3.Distance(GSDRI.CornerRR, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerRR, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime - Node1Width;
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true) * -1f;
                tPos2 = GSDRI.Node2.tTime - Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true) * -1f;
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosRR = tVectRR + (tDir * DistFromCorner);
                //RL:
                Node1Width = (Vector3.Distance(GSDRI.CornerRL, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerRL, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime + Node1Width;
                if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
                {
                    tPos1 = GSDRI.Node1.tTime;
                }
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true);
                tPos2 = GSDRI.Node2.tTime - Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true) * -1f;
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosRL = tVectRL + (tDir * DistFromCorner);
                //LL:
                Node1Width = (Vector3.Distance(GSDRI.CornerLL, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerLL, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime + Node1Width;
                if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
                {
                    tPos1 = GSDRI.Node1.tTime;
                }
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true);
                tPos2 = GSDRI.Node2.tTime + Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true);
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosLL = tVectLL + (tDir * DistFromCorner);
                //LR:
                Node1Width = (Vector3.Distance(GSDRI.CornerLR, GSDRI.Node1.pos) + ShoulderWidth1) / GSDRI.Node1.GSDSpline.distance;
                Node2Width = (Vector3.Distance(GSDRI.CornerLR, GSDRI.Node2.pos) + ShoulderWidth2) / GSDRI.Node2.GSDSpline.distance;
                tPos1 = GSDRI.Node1.tTime - Node1Width;
                tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1, true) * -1f;
                tPos2 = GSDRI.Node2.tTime + Node2Width;
                tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2, true);
                tDir = (tTan1.normalized + tTan2.normalized).normalized;
                tPosLR = tVectLR + (tDir * DistFromCorner);
            }
            tPosRR.y = GSDRI.SignHeight;
            tPosRL.y = GSDRI.SignHeight;
            tPosLL.y = GSDRI.SignHeight;
            tPosLR.y = GSDRI.SignHeight;

            //			GameObject tObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
            //			tObj.transform.localScale = new Vector3(0.2f,20f,0.2f);
            //			tObj.transform.name = "temp22_RR";
            //			tObj.transform.position = tPosRR;
            //			tObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
            //			tObj.transform.localScale = new Vector3(0.2f,20f,0.2f);
            //			tObj.transform.name = "temp22_RL";
            //			tObj.transform.position = tPosRL;
            //			tObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
            //			tObj.transform.localScale = new Vector3(0.2f,20f,0.2f);
            //			tObj.transform.name = "temp22_LL";
            //			tObj.transform.position = tPosLL;
            //			tObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
            //			tObj.transform.localScale = new Vector3(0.2f,20f,0.2f);
            //			tObj.transform.name = "temp22_LR";
            //			tObj.transform.position = tPosLR;
        }


        //	
        //		public static void GetOrigFour(GSDRoadIntersection GSDRI, out Vector3 tPosRR, out Vector3 tPosRL, out Vector3 tPosLL, out Vector3 tPosLR){
        //			//Get four points:
        //			float tPos1 = 0f;
        //			float tPos2 = 0f;
        //			Vector3 tTan1 = default(Vector3);
        //			Vector3 tTan2 = default(Vector3);
        //			float Node1Width = -1f;
        //			float Node2Width = -1f;
        //			Vector3 tDirRR = default(Vector3);
        //			Vector3 tDirRL = default(Vector3);
        //			Vector3 tDirLL = default(Vector3);
        //			Vector3 tDirLR = default(Vector3);
        //			float tAngleRR = 85f;
        //			float tAngleRL = 85f;
        //			float tAngleLL = 85f;
        //			float tAngleLR = 85f;
        //			float ShoulderWidth1 = GSDRI.Node1.GSDSpline.tRoad.opt_ShoulderWidth;
        //			float ShoulderWidth2 = GSDRI.Node2.GSDSpline.tRoad.opt_ShoulderWidth;
        //			Vector3 xPos1 = default(Vector3);
        //			Vector3 xPos2 = default(Vector3);
        //			
        //			if(!GSDRI.bFlipped){
        //				//RR:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerRR,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerRR,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime - Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true) * -1f;
        //				tPos2 = GSDRI.Node2.tTime + Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tDirRR = (tTan1.normalized + tTan2.normalized).normalized;
        //				//tAngleRR = Vector3.Angle(tTan1,tTan2);
        //				tAngleRR = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//RL:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerRL,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerRL,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime + Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true);
        //				tPos2 = GSDRI.Node2.tTime + Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tDirRL = (tTan1.normalized + tTan2.normalized).normalized;
        //				//tAngleRL = Vector3.Angle(tTan1,tTan2);
        //				tAngleRL = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//LL:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerLL,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerLL,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime + Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true);
        //				tPos2 = GSDRI.Node2.tTime - Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true) * -1f;
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tDirLL = (tTan1.normalized + tTan2.normalized).normalized;
        //				//tAngleLL = Vector3.Angle(tTan1,tTan2);
        //				tAngleLL = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//LR:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerLR,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerLR,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime - Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true) * -1f;
        //				tPos2 = GSDRI.Node2.tTime - Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true) * -1f;
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tDirLR = (tTan1.normalized + tTan2.normalized).normalized;
        //				//tAngleLR = Vector3.Angle(tTan1,tTan2);
        //				tAngleLR = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //			}else{
        //				//RR:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerRR,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerRR,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime - Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true) * -1f;
        //				tPos2 = GSDRI.Node2.tTime - Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true) * -1f;
        //				tDirRR = (tTan1.normalized + tTan2.normalized).normalized;
        ////				tAngleRR = Vector3.Angle(tTan1,tTan2);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tAngleRR = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//RL:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerRL,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerRL,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime + Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true);
        //				tPos2 = GSDRI.Node2.tTime - Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true) * -1f;
        //				tDirRL = (tTan1.normalized + tTan2.normalized).normalized;
        ////				tAngleRL = Vector3.Angle(tTan1,tTan2);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tAngleRL = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//LL:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerLL,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerLL,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime + Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true);
        //				tPos2 = GSDRI.Node2.tTime + Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true);
        //				tDirLL = (tTan1.normalized + tTan2.normalized).normalized;
        ////				tAngleLL = Vector3.Angle(tTan1,tTan2);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tAngleLL = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //				//LR:
        //				Node1Width = (Vector3.Distance(GSDRI.CornerLR,GSDRI.Node1.pos) + ShoulderWidth1)/GSDRI.Node1.GSDSpline.distance;
        //				Node2Width = (Vector3.Distance(GSDRI.CornerLR,GSDRI.Node2.pos) + ShoulderWidth2)/GSDRI.Node2.GSDSpline.distance;
        //				tPos1 = GSDRI.Node1.tTime - Node1Width;
        //				tTan1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1,true) * -1f;
        //				tPos2 = GSDRI.Node2.tTime + Node2Width;
        //				tTan2 = GSDRI.Node2.GSDSpline.GetSplineValue(tPos2,true);
        //				tDirLR = (tTan1.normalized + tTan2.normalized).normalized;
        //				//tAngleLR = Vector3.Angle(tTan1,tTan2);
        //				xPos1 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos1);
        //				xPos2 = GSDRI.Node1.GSDSpline.GetSplineValue(tPos2);
        //				tAngleLR = Vector3.Angle(xPos1 - GSDRI.Node1.pos,xPos2 - GSDRI.Node1.pos);
        //			}	
        //			
        //			//D = B*cos(angle/2)
        //			float tWidth = GSDRI.Node1.GSDSpline.tRoad.opt_RoadWidth * 0.5f;
        //			float tAngleRR_Opp = 180f - tAngleRR;
        //			float tAngleRL_Opp = 180f - tAngleRL;
        //			float tAngleLL_Opp = 180f - tAngleLL;
        //			float tAngleLR_Opp = 180f - tAngleLR;
        //
        //			float tOffSetRR = tWidth*(Mathf.Cos((tAngleRR*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetRL = tWidth*(Mathf.Cos((tAngleRL*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetLL = tWidth*(Mathf.Cos((tAngleLL*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetLR = tWidth*(Mathf.Cos((tAngleLR*0.5f)*Mathf.Deg2Rad));
        //			
        //			float tOffSetRR_opp = tWidth*(Mathf.Cos((tAngleRR_Opp*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetRL_opp = tWidth*(Mathf.Cos((tAngleRL_Opp*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetLL_opp = tWidth*(Mathf.Cos((tAngleLL_Opp*0.5f)*Mathf.Deg2Rad));
        //			float tOffSetLR_opp = tWidth*(Mathf.Cos((tAngleLR_Opp*0.5f)*Mathf.Deg2Rad));
        //			
        //			Vector3 tPos = GSDRI.Node1.pos;
        //			
        ////			tOffSetRR *=2f;
        ////			tOffSetRL *=2f;
        ////			tOffSetLL *=2f;
        ////			tOffSetLR *=2f;
        //			
        //			tPosRR = tPos + (tDirRR * (tOffSetRR+tOffSetRR_opp));
        //			tPosRL = tPos + (tDirRL * (tOffSetRL+tOffSetRL_opp));
        //			tPosLL = tPos + (tDirLL * (tOffSetLL+tOffSetLL_opp));
        //			tPosLR = tPos + (tDirLR * (tOffSetLR+tOffSetLR_opp));
        //			
        //			GameObject tObj = GameObject.Find("temp22_RR"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_RL"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_LL"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_LR"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			
        //			GameObject tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosRR;
        //			tCubeRR.transform.name = "temp22_RR";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosRL;
        //			tCubeRR.transform.name = "temp22_RL";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosLL;
        //			tCubeRR.transform.name = "temp22_LL";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosLR;
        //			tCubeRR.transform.name = "temp22_LR";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //		}
        //	
        //		public static void GetCornerVectors_Test(GSDRoadIntersection GSDRI, out Vector3 tPosRR, out Vector3 tPosRL, out Vector3 tPosLL, out Vector3 tPosLR){
        //			GSDSplineN tNode = null;
        //			GSDSplineC tSpline = null;
        //
        //			tNode = GSDRI.Node1;
        //			tSpline = tNode.GSDSpline;
        //			float tOffset = tSpline.tRoad.opt_RoadWidth * 0.5f;
        //			float tPos1 = tNode.tTime - (tOffset/tSpline.distance);
        //			float tPos2 = tNode.tTime + (tOffset/tSpline.distance);
        //			Vector3 tVect1 = tSpline.GetSplineValue(tPos1);	
        //			Vector3 POS1 = tSpline.GetSplineValue(tPos1,true);
        //			Vector3 tVect2 = tSpline.GetSplineValue(tPos2);	
        //			Vector3 POS2 = tSpline.GetSplineValue(tPos2,true);
        //			tPosRR = (tVect1 + new Vector3(5f*POS1.normalized.z,0,5f*-POS1.normalized.x));
        //			tPosLR = (tVect1 + new Vector3(5f*-POS1.normalized.z,0,5f*POS1.normalized.x));
        //			tPosRL = (tVect2 + new Vector3(5f*POS2.normalized.z,0,5f*-POS2.normalized.x));
        //			tPosLL = (tVect2 + new Vector3(5f*-POS2.normalized.z,0,5f*POS2.normalized.x));
        //			
        //			tNode = GSDRI.Node2;
        //			tSpline = tNode.GSDSpline;
        //			tOffset = tSpline.tRoad.opt_RoadWidth * 0.5f;
        //			tPos1 = tNode.tTime - (tOffset/tSpline.distance);
        //			tPos2 = tNode.tTime + (tOffset/tSpline.distance);
        //			tVect1 = tSpline.GetSplineValue(tPos1);	
        //			POS1 = tSpline.GetSplineValue(tPos1,true);
        //			tVect2 = tSpline.GetSplineValue(tPos2);	
        //			POS2 = tSpline.GetSplineValue(tPos2,true);
        //			Vector3 tPosRR2 = default(Vector3);
        //			Vector3 tPosLR2 = default(Vector3);
        //			Vector3 tPosRL2 = default(Vector3);
        //			Vector3 tPosLL2 = default(Vector3);
        //			
        //			if(GSDRI.bFlipped){
        //				tPosRL2 = (tVect1 + new Vector3(5f*POS1.normalized.z,0,5f*-POS1.normalized.x));
        //				tPosRR2 = (tVect1 + new Vector3(5f*-POS1.normalized.z,0,5f*POS1.normalized.x));
        //				tPosLL2 = (tVect2 + new Vector3(5f*POS2.normalized.z,0,5f*-POS2.normalized.x));
        //				tPosLR2 = (tVect2 + new Vector3(5f*-POS2.normalized.z,0,5f*POS2.normalized.x));
        //			}else{
        //				tPosLR2 = (tVect1 + new Vector3(5f*POS1.normalized.z,0,5f*-POS1.normalized.x));
        //				tPosLL2 = (tVect1 + new Vector3(5f*-POS1.normalized.z,0,5f*POS1.normalized.x));
        //				tPosRR2 = (tVect2 + new Vector3(5f*POS2.normalized.z,0,5f*-POS2.normalized.x));
        //				tPosRL2 = (tVect2 + new Vector3(5f*-POS2.normalized.z,0,5f*POS2.normalized.x));
        //			}
        //			
        //			tPosRR = ((tPosRR-tPosRR2)*0.5f)+tPosRR;
        //			tPosLR = ((tPosLR-tPosLR2)*0.5f)+tPosLR;
        //			tPosRL = ((tPosRL-tPosRL2)*0.5f)+tPosRL;
        //			tPosLL = ((tPosLL-tPosLL2)*0.5f)+tPosLL;
        //			
        //			
        //						GameObject tObj = GameObject.Find("temp22_RR"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_RL"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_LL"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			tObj = GameObject.Find("temp22_LR"); if(tObj != null){ Object.DestroyImmediate(tObj); }
        //			
        //			GameObject tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosRR;
        //			tCubeRR.transform.name = "temp22_RR";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosRL;
        //			tCubeRR.transform.name = "temp22_RL";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosLL;
        //			tCubeRR.transform.name = "temp22_LL";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //			
        //			tCubeRR = GameObject.CreatePrimitive(PrimitiveType.Cube);
        //			tCubeRR.transform.position = tPosLR;
        //			tCubeRR.transform.name = "temp22_LR";
        //			tCubeRR.transform.localScale = new Vector3(0.2f,20f,0.2f);
        //		}
        //	
    }


    public static class GSDIntersections
    {
        public class iConstructionMaker
        {
            //Lanes:
            public List<Vector3> iBLane0L, iBLane0R;
            public List<Vector3> iBLane1L, iBLane1R;
            public List<Vector3> iBLane2L, iBLane2R;
            public List<Vector3> iBLane3L, iBLane3R;
            public List<Vector3> iFLane0L, iFLane0R;
            public List<Vector3> iFLane1L, iFLane1R;
            public List<Vector3> iFLane2L, iFLane2R;
            public List<Vector3> iFLane3L, iFLane3R;
            //Main plate:
            public List<Vector3> iBMainPlateL; public List<Vector3> iBMainPlateR;
            public List<Vector3> iFMainPlateL; public List<Vector3> iFMainPlateR;
            //Front marker plates:
            public List<Vector3> iBMarkerPlateL; public List<Vector3> iBMarkerPlateR;
            public List<Vector3> iFMarkerPlateL; public List<Vector3> iFMarkerPlateR;

            public float tempconstruction_InterStart;
            public float tempconstruction_InterEnd;
            public bool tempconstruction_HasProcessed_Inter1 = false;
            public bool tempconstruction_HasProcessed_Inter2 = false;

            public List<Vector2> tempconstruction_R_RightTurn;
            public List<Vector2> tempconstruction_L_RightTurn;
            public List<Vector2> tempconstruction_R;
            public List<Vector2> tempconstruction_L;

            public float tempconstruction_MinXR = 0f;
            public float tempconstruction_MaxXR = 0f;
            public float tempconstruction_MinXL = 0f;
            public float tempconstruction_MaxXL = 0f;

            public float tempconstruction_MinYR = 0f;
            public float tempconstruction_MaxYR = 0f;
            public float tempconstruction_MinYL = 0f;
            public float tempconstruction_MaxYL = 0f;

            public bool bBLane0Done = false;
            public bool bBLane1Done = false;
            public bool bBLane2Done = false;
            public bool bBLane3Done = false;
            public bool bFLane0Done = false;
            public bool bFLane1Done = false;
            public bool bFLane2Done = false;
            public bool bFLane3Done = false;

            public bool bBLane0Done_Final = false;
            public bool bBLane1Done_Final = false;
            public bool bBLane2Done_Final = false;
            public bool bBLane3Done_Final = false;
            public bool bFLane0Done_Final = false;
            public bool bFLane1Done_Final = false;
            public bool bFLane2Done_Final = false;
            public bool bFLane3Done_Final = false;

            public bool bBLane0Done_Final_ThisRound = false;
            public bool bBLane1Done_Final_ThisRound = false;
            public bool bBLane2Done_Final_ThisRound = false;
            public bool bBLane3Done_Final_ThisRound = false;
            public bool bFLane0Done_Final_ThisRound = false;
            public bool bFLane1Done_Final_ThisRound = false;
            public bool bFLane2Done_Final_ThisRound = false;
            public bool bFLane3Done_Final_ThisRound = false;

            public bool bFDone = false;
            public bool bBDone = false;

            public bool bIsFrontFirstRound = false;
            public bool bIsFrontFirstRoundTriggered = false;

            public Vector3 f0LAttempt = default(Vector3);
            public Vector3 f1LAttempt = default(Vector3);
            public Vector3 f2LAttempt = default(Vector3);
            public Vector3 f3LAttempt = default(Vector3);
            public Vector3 f0RAttempt = default(Vector3);
            public Vector3 f1RAttempt = default(Vector3);
            public Vector3 f2RAttempt = default(Vector3);
            public Vector3 f3RAttempt = default(Vector3);

            public bool bNode1RLTriggered = false;

            public bool bDepressDoneR = false;
            public bool bDepressDoneL = false;

            public bool bBackRRpassed = false;

            public List<Vector3> iBLane0_Real;

            public Vector3 ShoulderBL_Start = default(Vector3);
            public Vector3 ShoulderBR_Start = default(Vector3);
            public Vector3 ShoulderFL_Start = default(Vector3);
            public Vector3 ShoulderFR_Start = default(Vector3);

            public Vector3 ShoulderBL_End = default(Vector3);
            public Vector3 ShoulderBR_End = default(Vector3);
            public Vector3 ShoulderFL_End = default(Vector3);
            public Vector3 ShoulderFR_End = default(Vector3);

            public int ShoulderBL_StartIndex = -1;
            public int ShoulderBR_StartIndex = -1;
            public int ShoulderFL_StartIndex = -1;
            public int ShoulderFR_StartIndex = -1;


            public void Nullify()
            {

                //Intersection construction:
                if (iBLane0L != null)
                {
                    iBLane0L.Clear();
                    iBLane0L = null;
                }
                if (iBLane0R != null)
                {
                    iBLane0R.Clear();
                    iBLane0R = null;
                }
                if (iBLane1L != null)
                {
                    iBLane1L.Clear();
                    iBLane1L = null;
                }
                if (iBLane1R != null)
                {
                    iBLane1R.Clear();
                    iBLane1R = null;
                }
                if (iBLane2L != null)
                {
                    iBLane2L.Clear();
                    iBLane2L = null;
                }
                if (iBLane2R != null)
                {
                    iBLane2R.Clear();
                    iBLane2R = null;
                }
                if (iBLane3L != null)
                {
                    iBLane3L.Clear();
                    iBLane3L = null;
                }
                if (iBLane3R != null)
                {
                    iBLane3R.Clear();
                    iBLane3R = null;
                }
                if (iFLane0L != null)
                {
                    iFLane0L.Clear();
                    iFLane0L = null;
                }
                if (iFLane0R != null)
                {
                    iFLane0R.Clear();
                    iFLane0R = null;
                }
                if (iFLane1L != null)
                {
                    iFLane1L.Clear();
                    iFLane1L = null;
                }
                if (iFLane1R != null)
                {
                    iFLane1R.Clear();
                    iFLane1R = null;
                }
                if (iFLane2L != null)
                {
                    iFLane2L.Clear();
                    iFLane2L = null;
                }
                if (iFLane2R != null)
                {
                    iFLane2R.Clear();
                    iFLane2R = null;
                }
                if (iFLane3L != null)
                {
                    iFLane3L.Clear();
                    iFLane3L = null;
                }
                if (iFLane3R != null)
                {
                    iFLane3R.Clear();
                    iFLane3R = null;
                }
                if (iBMainPlateL != null)
                {
                    iBMainPlateL.Clear();
                    iBMainPlateL = null;
                }
                if (iBMainPlateR != null)
                {
                    iBMainPlateR.Clear();
                    iBMainPlateR = null;
                }
                if (iFMainPlateL != null)
                {
                    iFMainPlateL.Clear();
                    iFMainPlateL = null;
                }
                if (iFMainPlateR != null)
                {
                    iFMainPlateR.Clear();
                    iFMainPlateR = null;
                }

                if (iBMarkerPlateL != null)
                {
                    iBMarkerPlateL.Clear();
                    iBMarkerPlateL = null;
                }
                if (iBMarkerPlateR != null)
                {
                    iBMarkerPlateR.Clear();
                    iBMarkerPlateR = null;
                }
                if (iFMarkerPlateL != null)
                {
                    iFMarkerPlateL.Clear();
                    iFMarkerPlateL = null;
                }
                if (iFMarkerPlateR != null)
                {
                    iFMarkerPlateR.Clear();
                    iFMarkerPlateR = null;
                }

                if (tempconstruction_R != null)
                {
                    tempconstruction_R = null;
                }
                if (tempconstruction_L != null)
                {
                    tempconstruction_L = null;
                }
            }


            public iConstructionMaker()
            {
                Nullify();

                iBLane0_Real = new List<Vector3>();

                //Lanes:
                iBLane0L = new List<Vector3>();
                iBLane0R = new List<Vector3>();
                iBLane1L = new List<Vector3>();
                iBLane1R = new List<Vector3>();
                iBLane2L = new List<Vector3>();
                iBLane2R = new List<Vector3>();
                iBLane3L = new List<Vector3>();
                iBLane3R = new List<Vector3>();
                iFLane0L = new List<Vector3>();
                iFLane0R = new List<Vector3>();
                iFLane1L = new List<Vector3>();
                iFLane1R = new List<Vector3>();
                iFLane2L = new List<Vector3>();
                iFLane2R = new List<Vector3>();
                iFLane3L = new List<Vector3>();
                iFLane3R = new List<Vector3>();
                //Main plate:
                iBMainPlateL = new List<Vector3>();
                iBMainPlateR = new List<Vector3>();
                iFMainPlateL = new List<Vector3>();
                iFMainPlateR = new List<Vector3>();

                iBMarkerPlateL = new List<Vector3>();
                iBMarkerPlateR = new List<Vector3>();
                iFMarkerPlateL = new List<Vector3>();
                iFMarkerPlateR = new List<Vector3>();

                tempconstruction_HasProcessed_Inter1 = false;
                tempconstruction_HasProcessed_Inter2 = false;
                tempconstruction_MinXR = 20000000f;
                tempconstruction_MaxXR = 0f;
                tempconstruction_MinXL = 20000000f;
                tempconstruction_MaxXL = 0f;
                tempconstruction_MinYR = 20000000f;
                tempconstruction_MaxYR = 0f;
                tempconstruction_MinYL = 20000000f;
                tempconstruction_MaxYL = 0f;

                bBLane0Done = false;
                bBLane1Done = false;
                bBLane2Done = false;
                bBLane3Done = false;
                bFLane0Done = false;
                bFLane1Done = false;
                bFLane2Done = false;
                bFLane3Done = false;
            }
        }


        public static GameObject CreateIntersection(GSDSplineN tNode, GSDSplineN xNode)
        {
            return CreateIntersection_Do(tNode, xNode);
        }


        private static GameObject CreateIntersection_Do(GSDSplineN tNode, GSDSplineN xNode)
        {
            float RoadMod = 10f;
            GameObject SystemObj = tNode.transform.parent.parent.parent.gameObject;
            if (!SystemObj)
            {
                Debug.LogWarning("Could not find GSD road system master object.");
                return null;
            }
            GameObject InterMaster = null;
            int cCount = SystemObj.transform.childCount;
            for (int i = 0; i < cCount; i++)
            {
                if (SystemObj.transform.GetChild(i).transform.name.ToLower() == "intersections")
                {
                    InterMaster = SystemObj.transform.GetChild(i).gameObject;
                }
            }
            if (!InterMaster)
            {
                InterMaster = new GameObject("Intersections");
                InterMaster.transform.parent = SystemObj.transform;
            }
            if (!InterMaster)
            {
                Debug.LogWarning("Could not find intersections master object for this road system.");
                return null;
            }
            cCount = InterMaster.transform.childCount;

            GameObject tObj = new GameObject("Inter" + (cCount + 1).ToString());
            tObj.transform.parent = InterMaster.transform;
            GSDRoadIntersection GSDRI = tObj.AddComponent<GSDRoadIntersection>();
            GSDRI.IgnoreSide = -1;
            GSDRI.bFirstSpecial_First = false;
            GSDRI.bFirstSpecial_Last = false;
            GSDRI.bSecondSpecial_First = false;
            GSDRI.bSecondSpecial_Last = false;

            GSDSplineN tNode1 = null;
            GSDSplineN tNode2 = null;
            if (tNode.GSDSpline == xNode.GSDSpline)
            {
                if (tNode.idOnSpline < xNode.idOnSpline)
                {
                    tNode1 = tNode;
                    tNode2 = xNode;
                }
                else
                {
                    tNode1 = xNode;
                    tNode2 = tNode;
                }
            }
            else
            {
                tNode1 = tNode;
                tNode2 = xNode;
            }

            //If 3way, always add the single node as primary:
            if (tNode.bIsEndPoint)
            {
                tNode1 = tNode;
                tNode2 = xNode;
            }
            else if (xNode.bIsEndPoint)
            {
                tNode1 = xNode;
                tNode2 = tNode;
            }

            tNode1.Intersection_OtherNode = tNode2;
            tNode2.Intersection_OtherNode = tNode1;

            if (tNode1.bIsEndPoint || tNode2.bIsEndPoint)
            {
                GSDRI.iType = GSDRoadIntersection.IntersectionTypeEnum.ThreeWay;
            }

            GSDSplineN zNode = null;
            if (tNode1.bIsEndPoint)
            {
                bool bFirstNode = false;
                bool bAlreadyNode = false;
                if (tNode1.idOnSpline == 1 || tNode1.idOnSpline == 0)
                {
                    bFirstNode = true;
                }
                if (bFirstNode && tNode1.idOnSpline == 1 && tNode1.GSDSpline.mNodes[0].bSpecialEndNode_IsStart)
                {
                    bAlreadyNode = true;
                }
                else if (!bFirstNode && tNode1.idOnSpline == tNode1.GSDSpline.GetNodeCount() - 2 && tNode1.GSDSpline.mNodes[tNode1.GSDSpline.GetNodeCount() - 1].bSpecialEndNode_IsEnd)
                {
                    bAlreadyNode = true;
                }

                Vector3 tPos = default(Vector3);
                if (bFirstNode)
                {
                    tPos = ((tNode1.tangent * -1f).normalized * (tNode1.GSDSpline.tRoad.RoadWidth() * RoadMod)) + tNode1.pos;
                }
                else
                {
                    tPos = (tNode1.GSDSpline.GetSplineValue(0.999f, true).normalized * (tNode1.GSDSpline.tRoad.RoadWidth() * RoadMod)) + tNode1.pos;
                }

                if (!bAlreadyNode)
                {
                    if (bFirstNode)
                    {
                        zNode = GSD.Roads.GSDConstruction.InsertNode(tNode1.GSDSpline.tRoad, true, tPos, false, 0, true, true);
                        zNode.bSpecialEndNode_IsStart = true;
                        zNode.bSpecialIntersection = true;
                        zNode.tangent = tNode1.tangent;
                    }
                    else
                    {
                        zNode = GSD.Roads.GSDConstruction.CreateNode(tNode1.GSDSpline.tRoad, true, tPos, true);
                        zNode.bSpecialEndNode_IsEnd = true;
                        zNode.bSpecialIntersection = true;
                        zNode.tangent = tNode1.tangent;
                    }
                }
                else
                {
                    if (bFirstNode)
                    {
                        tNode1.GSDSpline.mNodes[0].transform.position = tPos;
                    }
                    else
                    {
                        tNode1.GSDSpline.mNodes[tNode1.GSDSpline.GetNodeCount() - 1].transform.position = tPos;
                    }
                }
                if (bFirstNode)
                {
                    tNode1.GSDSpline.bSpecialStartControlNode = true;
                    GSDRI.bFirstSpecial_First = true;
                }
                else
                {
                    tNode1.GSDSpline.bSpecialEndControlNode = true;
                    GSDRI.bFirstSpecial_Last = true;
                }

            }
            else if (tNode2.bIsEndPoint)
            {
                bool bFirstNode = false;
                bool bAlreadyNode = false;
                if (tNode2.idOnSpline == 1 || tNode2.idOnSpline == 0)
                {
                    bFirstNode = true;
                }
                if (bFirstNode && tNode2.idOnSpline == 1 && tNode2.GSDSpline.mNodes[0].bSpecialEndNode_IsStart)
                {
                    bAlreadyNode = true;
                }
                else if (!bFirstNode && tNode2.idOnSpline == tNode2.GSDSpline.GetNodeCount() - 2 && tNode2.GSDSpline.mNodes[tNode2.GSDSpline.GetNodeCount() - 1].bSpecialEndNode_IsEnd)
                {
                    bAlreadyNode = true;
                }

                Vector3 tPos = default(Vector3);
                if (bFirstNode)
                {
                    tPos = ((tNode2.tangent * -1f).normalized * (tNode2.GSDSpline.tRoad.RoadWidth() * RoadMod)) + tNode2.pos;
                }
                else
                {
                    tPos = (tNode2.GSDSpline.GetSplineValue(0.999f, true).normalized * (tNode2.GSDSpline.tRoad.RoadWidth() * RoadMod)) + tNode2.pos;
                }

                if (!bAlreadyNode)
                {
                    if (bFirstNode)
                    {
                        zNode = GSD.Roads.GSDConstruction.InsertNode(tNode2.GSDSpline.tRoad, true, tPos, false, 0, true, true);
                        zNode.bSpecialEndNode_IsStart = true;
                        zNode.bSpecialIntersection = true;
                        zNode.tangent = tNode2.tangent;
                    }
                    else
                    {
                        zNode = GSD.Roads.GSDConstruction.CreateNode(tNode2.GSDSpline.tRoad, true, tPos, true);
                        zNode.bSpecialEndNode_IsEnd = true;
                        zNode.bSpecialIntersection = true;
                        zNode.tangent = tNode2.tangent;
                    }
                }
                else
                {
                    if (bFirstNode)
                    {
                        tNode2.GSDSpline.mNodes[0].transform.position = tPos;
                    }
                    else
                    {
                        tNode2.GSDSpline.mNodes[tNode2.GSDSpline.GetNodeCount() - 1].transform.position = tPos;
                    }
                }
                if (bFirstNode)
                {
                    tNode2.GSDSpline.bSpecialStartControlNode = true;
                    GSDRI.bSecondSpecial_First = true;
                }
                else
                {
                    tNode2.GSDSpline.bSpecialEndControlNode = true;
                    GSDRI.bSecondSpecial_Last = true;
                }
            }

            //Undo crap:
            UnityEditor.Undo.RegisterCreatedObjectUndo(tObj, "Created intersection");

            GSDRI.Setup(tNode1, tNode2);
            tObj.transform.position = tNode.transform.position;

            GSDRI.ResetMaterials_All();

            //			if(GSDRI.bSameSpline){
            //				GSDRI.Node1.GSDSpline.tRoad.UpdateRoad();
            //			}else{
            //				GSDRI.Node1.GSDSpline.tRoad.UpdateRoad();
            //				GSDRI.Node2.GSDSpline.tRoad.UpdateRoad();
            //			}

            tNode1.ToggleHideFlags(true);
            tNode2.ToggleHideFlags(true);

            if (GSDRI != null && GSDRI.Node1 != null && GSDRI.Node2 != null)
            {
                if (!GSDRI.bSameSpline)
                {
                    GSDRI.Node1.GSDSpline.tRoad.PiggyBacks = new GSDSplineC[4];
                    GSDRI.Node1.GSDSpline.tRoad.PiggyBacks[0] = GSDRI.Node2.GSDSpline;

                    GSDRI.Node1.GSDSpline.tRoad.PiggyBacks[1] = GSDRI.Node1.GSDSpline;
                    GSDRI.Node1.GSDSpline.tRoad.PiggyBacks[2] = GSDRI.Node2.GSDSpline;
                    GSDRI.Node1.GSDSpline.tRoad.PiggyBacks[3] = GSDRI.Node1.GSDSpline;
                    //					GSDRI.Node1.GSDSpline.tRoad.PiggyBacks[4] = GSDRI.Node2.GSDSpline;
                }
                GSDRI.Node1.GSDSpline.tRoad.EditorUpdateMe = true;
            }

            return tObj;
        }


        public static Vector3[] GetCornerVectors_Test(GSDRoadIntersection GSDRI)
        {
            Vector3[] tVects = new Vector3[4];
            GSDSplineN tNode;
            tNode = GSDRI.Node1;
            GSDSplineC tSpline = tNode.GSDSpline;

            //RR = Node1 - 5, Node2 + 5
            //RL = Node1 + 5, Node2 + 5
            //LL = Node1 + 5, Node2 - 5
            //LR = Node1 - 5, Node2 - 5

            float tOffset = 5f;
            float tPos1 = tNode.tTime - (tOffset / tSpline.distance);
            float tPos2 = tNode.tTime + (tOffset / tSpline.distance);
            Vector3 tVect1 = tSpline.GetSplineValue(tPos1);
            Vector3 POS1 = tSpline.GetSplineValue(tPos1, true);
            Vector3 tVect2 = tSpline.GetSplineValue(tPos2);
            Vector3 POS2 = tSpline.GetSplineValue(tPos2, true);

            tVects[0] = (tVect1 + new Vector3(5f * POS1.normalized.z, 0, 5f * -POS1.normalized.x));
            tVects[1] = (tVect1 + new Vector3(5f * -POS1.normalized.z, 0, 5f * POS1.normalized.x));
            tVects[2] = (tVect2 + new Vector3(5f * POS2.normalized.z, 0, 5f * -POS2.normalized.x));
            tVects[3] = (tVect2 + new Vector3(5f * -POS2.normalized.z, 0, 5f * POS2.normalized.x));

            return tVects;
        }


        #region "Old intersection"
        public static void CreateIntersection(GSDRoadIntersection GSDRI)
        {
            //1. Overlap sphere to find all road objects within intersection:
            float iWidth = GSDRI.IntersectionWidth * 1.25f;
            Collider[] tColliders = Physics.OverlapSphere(GSDRI.transform.position, iWidth);
            if (tColliders == null || tColliders.Length < 1)
            {
                return;
            }
            List<GSDRoad> tRoads = new List<GSDRoad>();
            foreach (Collider tCollider in tColliders)
            {
                if (tCollider.transform.parent)
                {
                    GSDRoad tRoad = tCollider.transform.parent.GetComponent<GSDRoad>();
                    if (tRoad)
                    {
                        if (!tRoads.Contains(tRoad))
                        {
                            tRoads.Add(tRoad);
                        }
                    }
                }
            }

            //Flatten intersection area:
            float tHeight = -1f;
            FlattenIntersectionArea(ref tRoads, GSDRI, iWidth, out tHeight);

            //Create main intersection mesh:
            string tName = GSDRI.transform.name;
            Vector3[] tVects;
            CreateIntersectionMesh_Main(GSDRI, tHeight, out tVects, ref tName);

            //Now create the 4 text overlays:
            CreateIntersectionMesh_Outer(GSDRI, tVects, ref tName);

            //Update connected nodes:
            GSDNavigation.UpdateConnectedNodes();

            //Now initialize intersection objects:
            InitializeIntersectionObjects(GSDRI);
        }


        private static void FlattenIntersectionArea(ref List<GSDRoad> tRoads, GSDRoadIntersection GSDRI, float iWidth, out float tHeight)
        {
            //Cycle through each road and get all mesh vertices that are within range:
            Vector3 tInterPos = GSDRI.transform.position;
            float tInterPosY = tInterPos.y;
            foreach (GSDRoad tRoad in tRoads)
            {
                MeshFilter MF_Road = tRoad.MeshRoad.GetComponent<MeshFilter>();
                MeshFilter MF_Road_SR = tRoad.MeshShoR.GetComponent<MeshFilter>();
                MeshFilter MF_Road_SL = tRoad.MeshShoL.GetComponent<MeshFilter>();

                Mesh Road = MF_Road.sharedMesh;
                Mesh Road_SR = MF_Road_SR.sharedMesh;
                Mesh Road_SL = MF_Road_SL.sharedMesh;

                Vector3[] tVects = Road.vertices;
                Vector3[] tVects_SR = Road_SR.vertices;
                Vector3[] tVects_SL = Road_SL.vertices;
                int VertCount = Road.vertices.Length;
                bool bLeftToggle = true;
                for (int i = 0; i < VertCount; i += 2)
                {
                    if (Vector3.Distance(tVects[i], tInterPos) < iWidth)
                    {
                        tVects[i].y = tInterPosY;
                        tVects[i + 1].y = tInterPosY;
                        if (bLeftToggle)
                        {
                            //Left:
                            tVects_SL[i + 2].y = tInterPosY;
                            tVects_SL[i + 3].y = tInterPosY;
                        }
                        else
                        {
                            //Right:
                            tVects_SR[i - 2].y = tInterPosY;
                            tVects_SR[i - 1].y = tInterPosY;
                        }
                    }
                    bLeftToggle = !bLeftToggle;
                }
                //Main road:
                Road.vertices = tVects;
                Road.RecalculateNormals();
                MF_Road.sharedMesh = Road;
                //Right shoulder:
                Road_SR.vertices = tVects_SR;
                Road_SR.RecalculateNormals();
                MF_Road_SR.sharedMesh = Road_SR;
                //Left shoulder:
                Road_SL.vertices = tVects_SL;
                Road_SL.RecalculateNormals();
                MF_Road_SL.sharedMesh = Road_SL;
            }
            tHeight = tInterPosY;
        }


        private static bool V3Equal(Vector3 a, Vector3 b)
        {
            return Vector3.SqrMagnitude(a - b) < 0.0001f;
        }


        private static Vector3[] GetCornerVectors(GSDRoadIntersection GSDRI, bool bPrimary = true)
        {
            Vector3[] tVects = new Vector3[4];
            GSDSplineN tNode;
            if (bPrimary)
            {
                tNode = GSDRI.Node1;
            }
            else
            {
                tNode = GSDRI.Node2;
            }
            GSDSplineC tSpline = tNode.GSDSpline;

            float tOffset = 7f;
            float tPos1 = tNode.tTime - (tOffset / tSpline.distance);
            float tPos2 = tNode.tTime + (tOffset / tSpline.distance);
            Vector3 tVect1 = tSpline.GetSplineValue(tPos1);
            Vector3 POS1 = tSpline.GetSplineValue(tPos1, true);
            Vector3 tVect2 = tSpline.GetSplineValue(tPos2);
            Vector3 POS2 = tSpline.GetSplineValue(tPos2, true);

            tVects[0] = (tVect1 + new Vector3(5f * POS1.normalized.z, 0, 5f * -POS1.normalized.x));
            tVects[1] = (tVect1 + new Vector3(5f * -POS1.normalized.z, 0, 5f * POS1.normalized.x));
            tVects[2] = (tVect2 + new Vector3(5f * POS2.normalized.z, 0, 5f * -POS2.normalized.x));
            tVects[3] = (tVect2 + new Vector3(5f * -POS2.normalized.z, 0, 5f * POS2.normalized.x));

            return tVects;
        }


        private static Vector3[] GetExtendedVectors(GSDRoadIntersection GSDRI, bool bPrimary = true)
        {
            Vector3[] tVects = new Vector3[4];
            GSDSplineN tNode;
            if (bPrimary)
            {
                tNode = GSDRI.Node1;
            }
            else
            {
                tNode = GSDRI.Node2;
            }
            GSDSplineC tSpline = tNode.GSDSpline;
            Vector3 NodePos = tNode.transform.position;

            float tOffset = tNode.GSDSpline.tRoad.RoadWidth();
            float tOffset2 = tOffset * 0.5f;
            float tPos1 = tNode.tTime - (tOffset / tSpline.distance);
            float tPos2 = tNode.tTime + (tOffset / tSpline.distance);
            Vector3 tVect1 = tSpline.GetSplineValue(tPos1);
            Vector3 tVect2 = tSpline.GetSplineValue(tPos2);

            //Enforce distance:
            int SpamGuard = 0;
            int SGMax = 50;
            while (Vector3.Distance(tVect1, NodePos) < tOffset && SpamGuard < SGMax)
            {
                SpamGuard += 1;
                tPos1 -= (1f / tSpline.distance);
                tVect1 = tSpline.GetSplineValue(tPos1);
            }
            SpamGuard = 0;
            while (Vector3.Distance(tVect1, NodePos) > (tOffset * 1.2f) && SpamGuard < SGMax)
            {
                SpamGuard += 1;
                tPos1 += (0.25f / tSpline.distance);
                tVect1 = tSpline.GetSplineValue(tPos1);
            }
            SpamGuard = 0;
            while (Vector3.Distance(tVect2, NodePos) < tOffset && SpamGuard < SGMax)
            {
                SpamGuard += 1;
                tPos2 += (1f / tSpline.distance);
                tVect2 = tSpline.GetSplineValue(tPos2);
            }
            SpamGuard = 0;
            while (Vector3.Distance(tVect1, NodePos) > (tOffset * 1.2f) && SpamGuard < SGMax)
            {
                SpamGuard += 1;
                tPos2 -= (0.25f / tSpline.distance);
                tVect2 = tSpline.GetSplineValue(tPos2);
            }

            Vector3 POS1 = tSpline.GetSplineValue(tPos1, true);
            Vector3 POS2 = tSpline.GetSplineValue(tPos2, true);

            tVects[0] = (tVect1 + new Vector3(tOffset2 * POS1.normalized.z, 0, tOffset2 * -POS1.normalized.x));
            tVects[1] = (tVect1 + new Vector3(tOffset2 * -POS1.normalized.z, 0, tOffset2 * POS1.normalized.x));
            tVects[2] = (tVect2 + new Vector3(tOffset2 * POS2.normalized.z, 0, tOffset2 * -POS2.normalized.x));
            tVects[3] = (tVect2 + new Vector3(tOffset2 * -POS2.normalized.z, 0, tOffset2 * POS2.normalized.x));

            return tVects;
        }


        //Two non-parallel lines which may or may not touch each other have a point on each line which are closest
        //to each other. This function finds those two points. If the lines are not parallel, the function 
        //outputs true, otherwise false.
        private static bool ClosestPointsOnTwoLines(out Vector3 closestPointLine1, out Vector3 closestPointLine2, Vector3 linePoint1, Vector3 lineVec1, Vector3 linePoint2, Vector3 lineVec2)
        {

            closestPointLine1 = Vector3.zero;
            closestPointLine2 = Vector3.zero;

            float a = Vector3.Dot(lineVec1, lineVec1);
            float b = Vector3.Dot(lineVec1, lineVec2);
            float e = Vector3.Dot(lineVec2, lineVec2);

            float d = a * e - b * b;

            //lines are not parallel
            if (d != 0.0f)
            {

                Vector3 r = linePoint1 - linePoint2;
                float c = Vector3.Dot(lineVec1, r);
                float f = Vector3.Dot(lineVec2, r);

                float s = (b * f - c * e) / d;
                float t = (a * f - c * b) / d;

                closestPointLine1 = linePoint1 + lineVec1 * s;
                closestPointLine2 = linePoint2 + lineVec2 * t;

                return true;
            }

            else
            {
                return false;
            }
        }


        private static void CreateIntersectionMesh_Main(GSDRoadIntersection GSDRI, float tHeight, out Vector3[] tVects, ref string tName)
        {
            //Get four points:
            Vector3[] pVects = GetCornerVectors(GSDRI);
            Vector3[] sVects = GetCornerVectors(GSDRI, false);
            tVects = new Vector3[4];
            Vector3 oIntersection = new Vector3(0f, 0f, 0f);
            Vector3 oIntersection2 = new Vector3(0f, 0f, 0f);//Unused

            //			bool bIntersection;
            ClosestPointsOnTwoLines(out oIntersection, out oIntersection2, pVects[0], (pVects[2] - pVects[0]), sVects[0], (sVects[2] - sVects[0]));
            tVects[0] = oIntersection;
            tVects[0].y = tHeight;

            ClosestPointsOnTwoLines(out oIntersection, out oIntersection2, pVects[0], (pVects[2] - pVects[0]), sVects[1], (sVects[3] - sVects[1]));
            tVects[1] = oIntersection;
            tVects[1].y = tHeight;

            ClosestPointsOnTwoLines(out oIntersection, out oIntersection2, pVects[1], (pVects[3] - pVects[1]), sVects[0], (sVects[2] - sVects[0]));
            tVects[2] = oIntersection;
            tVects[2].y = tHeight;

            ClosestPointsOnTwoLines(out oIntersection, out oIntersection2, pVects[1], (pVects[3] - pVects[1]), sVects[1], (sVects[3] - sVects[1]));
            tVects[3] = oIntersection;
            tVects[3].y = tHeight;

            CreateIntersectionMesh_MainInternal(tVects, GSDRI.transform.gameObject, ref tName);
        }


        private static void CreateIntersectionMesh_MainInternal(Vector3[] tVerts, GameObject iObj, ref string tName)
        {
            Mesh tMesh = new Mesh();
            int MVL = 4;
            int triCount = (int) (4f * 1.5f);

            //			GameObject tObj;
            //			tObj = GameObject.Find("tInter1"); tObj.transform.position = tVerts[0];
            //			tObj = GameObject.Find("tInter2"); tObj.transform.position = tVerts[1];
            //			tObj = GameObject.Find("tInter3"); tObj.transform.position = tVerts[2];
            //			tObj = GameObject.Find("tInter4"); tObj.transform.position = tVerts[3];

            for (int index = 0; index < MVL; index++)
            {
                tVerts[index] -= iObj.transform.position;
            }
            tMesh.vertices = tVerts;
            tMesh.RecalculateBounds();

            int[] tri = new int[triCount];
            tri[0] = 0;
            tri[1] = 2;
            tri[2] = 1;
            tri[3] = 2;
            tri[4] = 3;
            tri[5] = 1;
            tMesh.triangles = tri;

            Vector3[] normals = new Vector3[MVL];
            for (int i = 0; i < MVL; i++)
            {
                normals[i] = -Vector3.forward;
            }
            tMesh.normals = normals;
            tMesh.RecalculateNormals();

            Vector2[] uv = new Vector2[MVL];
            uv[0] = new Vector2(0f, 0f);
            uv[1] = new Vector2(1f, 0f);
            uv[2] = new Vector2(0f, 1f);
            uv[3] = new Vector2(1f, 1f);
            tMesh.uv = uv;

            GSDRootUtil.ProcessTangents(ref tMesh);

            //Final processing:
            MeshFilter MF = iObj.GetComponent<MeshFilter>();
            if (!MF)
            {
                MF = iObj.AddComponent<MeshFilter>();
            }
            MF.sharedMesh = tMesh;
            //			MeshToFile(MF,GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Intersections/" + tName +".obj");

            MeshCollider MC = iObj.GetComponent<MeshCollider>();
            if (MC)
            {
                Object.DestroyImmediate(MC);
            }
            //if(!MC){ MC = iObj.AddComponent<MeshCollider>(); }
            //MC.sharedMesh = MF.sharedMesh;

            MeshRenderer MR = iObj.GetComponent<MeshRenderer>();
            if (!MR)
            {
                MR = iObj.AddComponent<MeshRenderer>();
            }
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            MR.receiveShadows = true;
            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDRoadIntersection.mat", MR);
        }


        private static void CreateIntersectionMesh_Outer(GSDRoadIntersection GSDRI, Vector3[] tVects, ref string tName)
        {
            Vector3[] bVects1 = GetExtendedVectors(GSDRI);
            Vector3[] bVects2 = GetExtendedVectors(GSDRI, false);
            Vector3[] eVects = new Vector3[16];
            eVects[0] = tVects[1];
            eVects[1] = tVects[0];
            eVects[2] = bVects2[3];
            eVects[3] = bVects2[2];
            //
            eVects[4] = tVects[3];
            eVects[5] = tVects[1];
            eVects[6] = bVects1[3];
            eVects[7] = bVects1[2];
            //
            eVects[8] = tVects[2];
            eVects[9] = tVects[3];
            eVects[10] = bVects2[0];
            eVects[11] = bVects2[1];
            //
            eVects[12] = tVects[0];
            eVects[13] = tVects[2];
            eVects[14] = bVects1[0];
            eVects[15] = bVects1[1];

            int cCount = GSDRI.transform.childCount;
            //			bool bOuter = false;
            GameObject tOuter = null;
            for (int index = 0; index < cCount; index++)
            {
                if (GSDRI.transform.GetChild(index).transform.name == "outer")
                {
                    tOuter = GSDRI.transform.GetChild(index).transform.gameObject;
                }
            }
            if (!tOuter)
            {
                tOuter = new GameObject("outer");
                tOuter.transform.parent = GSDRI.transform;
            }
            tOuter.transform.position = GSDRI.transform.position;

            //			GameObject tObj;
            //			tObj = GameObject.Find("tInter1"); tObj.transform.position = bVects2[0];
            //			tObj = GameObject.Find("tInter2"); tObj.transform.position = bVects2[1];
            //			tObj = GameObject.Find("tInter3"); tObj.transform.position = bVects2[2];
            //			tObj = GameObject.Find("tInter4"); tObj.transform.position = bVects2[3];

            CreateIntersectionMesh_OuterInternal(eVects, tOuter, GSDRI.transform.position, ref tName);
        }


        private static void CreateIntersectionMesh_OuterInternal(Vector3[] tVerts, GameObject iObj, Vector3 vOffset, ref string tName)
        {
            Mesh tMesh = new Mesh();
            int MVL = 16;
            int triCount = (int) (16f * 1.5f);

            for (int index = 0; index < MVL; index += 4)
            {
                //				tVerts[index] += vOffset;
                //				tVerts[index+1] += vOffset;
                tVerts[index + 2] -= vOffset;
                tVerts[index + 3] -= vOffset;
            }
            tMesh.vertices = tVerts;
            tMesh.RecalculateBounds();

            int[] tri = new int[triCount];
            int cTri = 0;
            for (int i = 0; i < triCount; i += 4)
            {
                if (i + 3 >= MVL)
                {
                    break;
                }
                tri[cTri] = i;
                cTri += 1;
                tri[cTri] = i + 2;
                cTri += 1;
                tri[cTri] = i + 1;
                cTri += 1;

                tri[cTri] = i + 2;
                cTri += 1;
                tri[cTri] = i + 3;
                cTri += 1;
                tri[cTri] = i + 1;
                cTri += 1;
            }
            tMesh.triangles = tri;

            Vector3[] normals = new Vector3[MVL];
            for (int i = 0; i < 4; i++)
            {
                normals[i] = -Vector3.forward;
            }
            tMesh.normals = normals;
            tMesh.RecalculateNormals();

            Vector2[] uv = new Vector2[MVL];
            for (int i = 0; i < MVL; i += 4)
            {
                uv[i] = new Vector2(1f, 1f);
                uv[i + 1] = new Vector2(0f, 1f);
                uv[i + 2] = new Vector2(1f, 0f);
                uv[i + 3] = new Vector2(0f, 0f);
            }
            tMesh.uv = uv;

            GSDRootUtil.ProcessTangents(ref tMesh);

            //Final processing:
            MeshFilter MF = iObj.GetComponent<MeshFilter>();
            if (!MF)
            {
                MF = iObj.AddComponent<MeshFilter>();
            }
            MF.sharedMesh = tMesh;

            //			MeshToFile(MF,GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Mesh/Intersections/" + tName +"-overlay.obj");

            MeshCollider MC = iObj.GetComponent<MeshCollider>();
            if (MC)
            {
                Object.DestroyImmediate(MC);
            }
            //			if(!MC){ MC = iObj.AddComponent<MeshCollider>(); }
            //			MC.sharedMesh = MF.sharedMesh;

            MeshRenderer MR = iObj.GetComponent<MeshRenderer>();
            if (!MR)
            {
                MR = iObj.AddComponent<MeshRenderer>();
            }
            MR.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            MR.receiveShadows = true;
            GSD.Roads.GSDRoadUtilityEditor.SetRoadMaterial(GSD.Roads.GSDRoadUtilityEditor.GetBasePath() + "/Materials/GSDInterText.mat", MR);
        }


        #region "Intersection creation"
        private static void InitializeIntersectionObjects(GSDRoadIntersection tGSDRI)
        {
            if (tGSDRI != null)
            {
                InitializeIntersectionObjects_Internal(tGSDRI);
            }
            else
            {
                Object[] iObjects = GameObject.FindObjectsOfType(typeof(GSDRoadIntersection));
                //Add intersection components, if necessary:
                foreach (GSDRoadIntersection GSDRI in iObjects)
                {
                    InitializeIntersectionObjects_Internal(GSDRI);
                }
            }
        }


        private static void InitializeIntersectionObjects_Internal(GSDRoadIntersection GSDRI)
        {
            //1. Determine 3-way or 4-way. # of corners for 3-way: 2. 4-way = 4.
            if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
            {
                GSDRI.CornerPoints = new GSDRoadIntersection.CornerPositionMaker[2];
            }
            else
            {
                GSDRI.CornerPoints = new GSDRoadIntersection.CornerPositionMaker[4];
            }

            //Contains int IDs of connected nodes:			
            List<GSDSplineN> tList = new List<GSDSplineN>();
            //Get all connected nodes on intersection node1:
            int cCount = GSDRI.Node1.id_connected.Count;
            GSDSplineN tNode;
            for (int index = 0; index < cCount; index++)
            {
                //tNode = GetNodeByID(GSDRI.Node1.id_connected[i]);
                tNode = GSDRI.Node1.node_connected[index];
                if (!tList.Contains(tNode))
                {
                    tList.Add(tNode);
                }
            }
            //Get all connected nodes on intersection node2:
            cCount = GSDRI.Node2.id_connected.Count;
            for (int index = 0; index < cCount; index++)
            {
                //tNode = GetNodeByID(GSDRI.Node2.id_connected[i]);
                tNode = GSDRI.Node2.node_connected[index];
                if (!tList.Contains(tNode))
                {
                    tList.Add(tNode);
                }
            }
            //Declare connected nodes:
            GSDSplineN n1, n2, n3, n4;
            n1 = tList[0];
            n2 = tList[1];
            n3 = tList[2];
            n4 = null;
            if (tList.Count > 3)
            {
                n4 = tList[3];
            }

            //Determine most relevant spline:
            GSDSplineC n1Spline = n1.GSDSpline;
            GSDSplineC n2Spline = n2.GSDSpline;
            GSDSplineC n3Spline = n3.GSDSpline;
            GSDSplineC n4Spline = null;
            if (n4 != null)
            {
                n4Spline = n4.GSDSpline;
            }

            //Get the point:
            Vector3 n1Point = GetFourCornerPoint(ref n1Spline, ref n1, GSDRI);
            Vector3 n2Point = GetFourCornerPoint(ref n2Spline, ref n2, GSDRI);
            Vector3 n3Point = GetFourCornerPoint(ref n3Spline, ref n3, GSDRI);
            Vector3 n4Point = new Vector3(0f, 0f, 0f);
            if (n4Spline != null)
            {
                n4Point = GetFourCornerPoint(ref n4Spline, ref n4, GSDRI);
            }

            //2. If 3 way, we know that 2 of the nodes have the same spline.
            if (1 == 1 && GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.ThreeWay)
            {
                //Should be size 3:
                if (tList.Count != 3)
                {
                    Debug.LogError("InitializeIntersections hashset != 3 connected on three way intersection, real size: " + tList.Count + " on intersection: " + GSDRI.transform.name);
                    return;
                }

                ProcessFourCorners(ref n1Point, ref n2Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n1Spline, n2Spline));
                ProcessFourCorners(ref n1Point, ref n3Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n1Spline, n3Spline));
                ProcessFourCorners(ref n2Point, ref n3Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n2Spline, n3Spline));

            }
            else if (GSDRI.iType == GSDRoadIntersection.IntersectionTypeEnum.FourWay)
            {
                //Should be size 3:
                if (tList.Count != 4)
                {
                    Debug.LogError("InitializeIntersections hashset != 4 connected on four way intersection, real size: " + tList.Count + " on intersection: " + GSDRI.transform.name);
                    return;
                }

                ProcessFourCorners(ref n1Point, ref n2Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n1Spline, n2Spline));
                ProcessFourCorners(ref n1Point, ref n3Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n1Spline, n3Spline));
                ProcessFourCorners(ref n1Point, ref n4Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n1Spline, n4Spline));
                ProcessFourCorners(ref n2Point, ref n3Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n2Spline, n3Spline));
                ProcessFourCorners(ref n2Point, ref n4Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n2Spline, n4Spline));
                ProcessFourCorners(ref n3Point, ref n4Point, GSDRI.transform.gameObject, GetLongestSplineDistance(n3Spline, n4Spline));
            }
        }
        #endregion


        #region "Intersection creation helpers"
        private static float GetLongestSplineDistance(GSDSplineC s1, GSDSplineC s2)
        {
            if (s1.distance > s2.distance)
            {
                return s1.distance;
            }
            else
            {
                return s2.distance;
            }
        }


        private static GSDSplineN GetNodeByID(int _ID)
        {
            Object[] SplineNodeObjects = GameObject.FindObjectsOfType(typeof(GSDSplineN));
            foreach (GSDSplineN tNode in SplineNodeObjects)
            {
                if (tNode.id == _ID)
                {
                    return tNode;
                }
            }
            return null;
        }


        static Vector3 GetFourCornerPoint(ref GSDSplineC tSpline, ref GSDSplineN tNode, GSDRoadIntersection GSDRI)
        {
            GSDSplineN iNode;
            if (tNode.node_connected.Contains(GSDRI.Node1))
            {
                iNode = GSDRI.Node1;
            }
            else
            {
                iNode = GSDRI.Node2;
            }

            float Pos1 = tNode.tTime;
            float iPos = iNode.tTime;

            float tFloat = 0;
            float NewSplinePos = 0;
            if (iPos >= Pos1)
            {
                tFloat = iPos - Pos1;
                tFloat = tFloat / 8;
                NewSplinePos = iPos - tFloat;
            }
            else
            {
                tFloat = Pos1 - iPos;
                tFloat = tFloat / 8;
                NewSplinePos = iPos + tFloat;
            }

            Vector3 tVect = new Vector3(0, 0, 0);

            bool bDone = false;
            int spamguard = 0;
            float tDist = 0f;
            while (!bDone && spamguard < 20000)
            {
                spamguard += 1;
                tVect = tSpline.GetSplineValue(NewSplinePos);
                tDist = Vector3.Distance(tVect, iNode.transform.position);

                if (tDist > 22f)
                {
                    //Get closer to intersection:
                    if (iPos >= NewSplinePos)
                    {
                        NewSplinePos += 0.001f;
                    }
                    else
                    {
                        NewSplinePos -= 0.001f;
                    }
                }
                else if (tDist < 20f)
                {
                    //Move away from intersection:
                    if (iPos >= NewSplinePos)
                    {
                        NewSplinePos -= 0.001f;
                    }
                    else
                    {
                        NewSplinePos += 0.001f;
                    }
                }
                else
                {
                    bDone = true;
                }
            }
            return tVect;
        }


        static void ProcessFourCorners(ref Vector3 n1, ref Vector3 n2, GameObject tIntersectionObject, float SplineDistance)
        {
            float Side1, Side2, Side3;
            Side1 = Vector3.Distance(n1, n2);
            Side2 = Vector3.Distance(tIntersectionObject.transform.position, n1);
            Side3 = Vector3.Distance(tIntersectionObject.transform.position, n2);
            float tAngle = AngleOfTriangle(Side2, Side3, Side1);
            if (tAngle > 20f && tAngle < 140f)
            {
                ProcessTwoCorners(ref tIntersectionObject, ref n1, ref n2, SplineDistance);
            }
        }


        static float AngleOfTriangle(float a, float b, float c)
        {
            float cAng = (a * a + b * b - c * c) / (2 * a * b);
            float rad = Mathf.Acos(cAng);
            float tFloat = Mathf.Rad2Deg * rad;
            return tFloat;
        }


        static void ProcessTwoCorners(ref GameObject tIntersectionObject, ref Vector3 n1, ref Vector3 n2, float SplineDistance)
        {
            GameObject tCorner = GameObject.CreatePrimitive(PrimitiveType.Cube);
            tCorner.transform.localScale = new Vector3(0.5f, 20f, 0.5f);
            tCorner.name = "CornerPosition";
            tCorner.transform.parent = tIntersectionObject.transform;
            tCorner.layer = 0;

            //Calculate the angle:
            Vector3 v3BA = n2 - tIntersectionObject.transform.position;
            Vector3 v3BC = n1 - tIntersectionObject.transform.position;
            Vector3 axis = Vector3.Cross(v3BA, v3BC);
            float angle = Vector3.Angle(v3BA, v3BC);
            Vector3 v3 = Quaternion.AngleAxis(angle / 2.0f, axis) * v3BA;
            //Vector3 v3 = (((n2.transform.position + n1.transform.position)/2) - tIntersectionObject.transform.position);

            tCorner.transform.rotation = Quaternion.LookRotation(v3);

            float tStep = 1.25f / SplineDistance;
            bool bSuccess = MoveCorner(tStep, 3f, ref tCorner, ref tIntersectionObject, v3);
            if (!bSuccess)
            {
                Debug.Log("not success");
                Object.DestroyImmediate(tCorner);
            }
        }


        static bool MoveCorner(float tStep, float tDist, ref GameObject tCorner, ref GameObject tIntersectionObject, Vector3 v3)
        {
            float tStart = 0.05f;
            bool bDone = false;
            int spamguard = 0;
            bool bHitRoad = false;
            Collider[] tCollider;
            while (!bDone)
            {
                spamguard += 1;
                tCorner.transform.position = tIntersectionObject.transform.position + (v3 * tStart);

                if (Vector3.Distance(tCorner.transform.position, tIntersectionObject.transform.position) > 25f)
                {
                    Debug.Log("too long");
                    bDone = true;
                    return false;
                }
                if (spamguard > 80000)
                {
                    Debug.Log("spamguard");
                    bDone = true;
                    return false;
                }

                //Cast sphere now
                bHitRoad = false;
                tCollider = Physics.OverlapSphere(tCorner.transform.position, tDist);
                if (tCollider == null || tCollider.Length < 1)
                {
                    tStart += tStep;
                    continue;
                }
                else
                {
                    for (int k = 0; k < tCollider.Length; k++)
                    {
                        if (tCollider[k].transform.name.ToLower().Contains("road"))
                        {
                            bHitRoad = true;
                            break;
                        }
                    }
                }

                if (bHitRoad)
                {
                    tStart += tStep;
                    continue;
                }
                else
                {
                    //Debug.Log ("Distance: " + Vector3.Distance(tCorner.transform.position,tIntersectionObject.transform.position));
                    bDone = true;
                    break;
                }
            }
            return true;
        }
        #endregion

        #endregion
    }


    public static class GSDNavigation
    {
        public static void UpdateConnectedNodes()
        {
            Init_ResetNavigationData();

            Object[] SplineObjects = GameObject.FindObjectsOfType(typeof(GSDSplineC));

            //Store connected spline nodes on each other:
            GSDSplineN xNode;
            foreach (GSDSplineC tSpline in SplineObjects)
            {
                int mNodeCount = tSpline.mNodes.Count;
                for (int i = 0; i < mNodeCount; i++)
                {
                    xNode = tSpline.mNodes[i];
                    //Add next node if not last node:
                    if ((i + 1) < mNodeCount)
                    {
                        xNode.id_connected.Add(tSpline.mNodes[i + 1].id);
                        xNode.node_connected.Add(tSpline.mNodes[i + 1]);
                    }
                    //Add prev node if not first node:
                    if (i > 0)
                    {
                        xNode.id_connected.Add(tSpline.mNodes[i - 1].id);
                        xNode.node_connected.Add(tSpline.mNodes[i - 1]);
                    }
                }
            }
        }


        public static void Init_ResetNavigationData()
        {
            Object[] tSplines = GameObject.FindObjectsOfType(typeof(GSDSplineC));
            int SplineCount = 0;
            int NodeCount = 0;
            foreach (GSDSplineC tSpline in tSplines)
            {
                SplineCount += 1;
                foreach (GSDSplineN tNode in tSpline.mNodes)
                {
                    NodeCount += 1;
                    tNode.ResetNavigationData();
                }
                tSpline.ResetNavigationData();
            }
        }
    }

#endif
}