/// <summary>
        /// Setup for the automatically probe spawning
        /// </summary>
        /// <param name="profile"></param>
        public static void CreateAutomaticProbes(AmbientLightingProfile profile, AmbientSkiesConsts.RenderPipelineSettings renderPipelineSettings)
        {
            GameObject oldReflectionProbe = GameObject.Find("Global Reflection Probe");

            if (oldReflectionProbe != null)
            {
                Object.DestroyImmediate(oldReflectionProbe);
                Debug.Log("Old Reflection Probe Destroyed");
            }

            GameObject relfectionParentObject = ReflectionProbeParenting(true);
            int        numberTerrains         = Terrain.activeTerrains.Length;

            if (numberTerrains == 0)
            {
                Debug.LogError("Unable to initiate probe spawning systen. No terrain found");
                return;
            }
            else
            {
                if (profile.reflectionProbesPerRow < 2)
                {
                    Debug.LogError("Please set Probes Per Row to a value of 2 or higher");
                    return;
                }
                else
                {
                    m_currentProbeCount = 0;

                    float seaLevel       = 0f;
                    bool  seaLevelActive = false;

#if GAIA_PRESENT
                    Gaia.GaiaSessionManager gaiaSession = Object.FindObjectOfType <Gaia.GaiaSessionManager>();
                    if (gaiaSession != null)
                    {
                        seaLevel       = profile.seaLevel;
                        seaLevelActive = true;
                    }
#else
                    seaLevel = profile.seaLevel;
#endif

                    for (int terrainIdx = 0; terrainIdx < numberTerrains; terrainIdx++)
                    {
                        Terrain terrain     = Terrain.activeTerrains[terrainIdx];
                        Vector3 terrainSize = terrain.terrainData.size;

                        for (int row = 0; row < profile.reflectionProbesPerRow; ++row)
                        {
                            for (int columns = 0; columns < profile.reflectionProbesPerRow; ++columns)
                            {
                                GameObject probeObject = new GameObject("Global Generated Reflection Probe");
                                Vector3    newPosition = probeObject.transform.position;
                                newPosition.x = ((columns + 1) * terrainSize.x / profile.reflectionProbesPerRow) - terrainSize.x / profile.reflectionProbesPerRow / 2f + terrain.transform.position.x;
                                newPosition.z = ((row + 1) * terrainSize.z / profile.reflectionProbesPerRow) - terrainSize.z / profile.reflectionProbesPerRow / 2f + terrain.transform.position.z;
                                float sampledHeight = terrain.SampleHeight(newPosition);

                                ReflectionProbe probeData = probeObject.AddComponent <ReflectionProbe>();
                                probeData.enabled       = false;
                                probeData.blendDistance = 0f;
                                probeData.cullingMask   = profile.reflectionprobeCullingMask;
                                probeData.farClipPlane  = profile.reflectionProbeClipPlaneDistance;
                                probeData.mode          = profile.reflectionProbeMode;
                                probeData.refreshMode   = profile.reflectionProbeRefresh;

                                if (seaLevelActive)
                                {
                                    newPosition.y = 500f + seaLevel + 0.2f;
                                }
                                else
                                {
                                    newPosition.y    = sampledHeight + profile.reflectionProbeOffset;
                                    probeData.center = new Vector3(0f, 0f - profile.reflectionProbeOffset - sampledHeight, 0f);
                                }


                                probeObject.transform.position = newPosition;
                                probeObject.transform.SetParent(relfectionParentObject.transform);

                                switch (profile.reflectionProbeResolution)
                                {
                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution16:
                                    probeData.resolution = 16;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution32:
                                    probeData.resolution = 32;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution64:
                                    probeData.resolution = 64;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution128:
                                    probeData.resolution = 128;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution256:
                                    probeData.resolution = 256;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution512:
                                    probeData.resolution = 512;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution1024:
                                    probeData.resolution = 1024;
                                    break;

                                case AmbientSkiesConsts.ReflectionProbeResolution.Resolution2048:
                                    probeData.resolution = 2048;
                                    break;
                                }

                                probeData.shadowDistance  = 80f;
                                probeData.size            = new Vector3(terrainSize.x / profile.reflectionProbesPerRow, terrainSize.y, terrainSize.z / profile.reflectionProbesPerRow);
                                probeData.timeSlicingMode = profile.reflectionProbeTimeSlicingMode;
                                probeData.hdr             = true;
                                probeData.shadowDistance  = profile.reflectionProbeShadowDistance;

                                //If HDRP
                                if (renderPipelineSettings == AmbientSkiesConsts.RenderPipelineSettings.HighDefinition)
                                {
#if HDPipeline && UNITY_2018_3_OR_NEWER
                                    HDAdditionalReflectionData reflectionData = probeObject.GetComponent <HDAdditionalReflectionData>();
                                    if (reflectionData == null)
                                    {
                                        reflectionData            = probeObject.AddComponent <HDAdditionalReflectionData>();
                                        reflectionData.multiplier = 1f;
                                    }
                                    else
                                    {
                                        reflectionData.multiplier = 1f;
                                    }
#endif
                                }

                                m_storedProbes.Add(probeData);
                                m_currentProbeCount++;
                            }
                        }
                    }

#if HDPipeline && GAIA_PRESENT
                    if (seaLevelActive)
                    {
                        GameObject planarObject = GameObject.Find("Gaia Water Planar Reflections Object");
                        if (planarObject == null)
                        {
                            planarObject = new GameObject("Gaia Water Planar Reflections Object");
                            PlanarReflectionProbe planar = planarObject.AddComponent <PlanarReflectionProbe>();
                            planar.mode                    = ProbeSettings.Mode.Realtime;
                            planar.realtimeMode            = ProbeSettings.RealtimeMode.OnEnable;
                            planar.influenceVolume.shape   = InfluenceShape.Box;
                            planar.influenceVolume.boxSize = new Vector3(10000f, 5f, 10000f);

                            planarObject.transform.position = new Vector3(0f, profile.seaLevel + 0.2f, 0f);
                            planarObject.transform.SetParent(relfectionParentObject.transform);
                        }
                    }
#endif

                    m_probeRenderActive = true;
                }
            }
        }
        /// <summary>
        /// Setup for the automatically probe spawning
        /// </summary>
        /// <param name="profile"></param>
        public static void CreateAutomaticProbes(AmbientLightingProfile profile)
        {
            GameObject lightParentObject = LightProbeParenting(true);
            int        numberTerrains    = Terrain.activeTerrains.Length;

            if (numberTerrains == 0)
            {
                Debug.LogError("Unable to initiate probe spawning systen. No terrain found");
                return;
            }
            else
            {
                if (profile.lightProbesPerRow < 2)
                {
                    Debug.LogError("Please set Light Probes Per Row to a value of 2 or higher");
                    return;
                }
                else
                {
                    LoadProbesFromScene();

                    GameObject lightProbeObject = GameObject.Find("Light Probes Group Data");
                    if (lightProbeObject == null)
                    {
                        lightProbeObject = new GameObject("Light Probes Group Data");
                    }

                    LightProbeGroup lightProbeData = lightProbeObject.GetComponent <LightProbeGroup>();
                    if (lightProbeData == null)
                    {
                        lightProbeData = lightProbeObject.AddComponent <LightProbeGroup>();
                        lightProbeData.probePositions = new Vector3[0];
                    }

                    m_probeLocations = null;

                    float seaLevel = 0f;

#if GAIA_PRESENT
                    Gaia.GaiaSessionManager gaiaSession = Object.FindObjectOfType <Gaia.GaiaSessionManager>();
                    if (gaiaSession != null)
                    {
                        seaLevel = profile.seaLevel;
                    }
                    else
                    {
                        seaLevel = profile.seaLevel;
                    }
#else
                    seaLevel = profile.seaLevel;
#endif

                    for (int terrainIdx = 0; terrainIdx < numberTerrains; terrainIdx++)
                    {
                        Terrain terrain     = Terrain.activeTerrains[terrainIdx];
                        Vector3 terrainSize = terrain.terrainData.size;

                        m_storedProbes = profile.lightProbesPerRow * profile.lightProbesPerRow;

                        for (int row = 0; row < profile.lightProbesPerRow; ++row)
                        {
                            for (int columns = 0; columns < profile.lightProbesPerRow; ++columns)
                            {
                                EditorUtility.DisplayProgressBar("Adding Probes", "Adding probes to terrain :" + terrain.name, (float)m_currentProbeCount / (float)m_storedProbes);

                                if (profile.lightProbeSpawnType == AmbientSkiesConsts.LightProbeSpawnType.AutomaticallyGenerated)
                                {
                                    Vector3 newPosition = lightProbeObject.transform.position - lightProbeData.transform.position;
                                    newPosition.x = ((columns + 1) * terrainSize.x / profile.lightProbesPerRow) - terrainSize.x / profile.lightProbesPerRow / 2f + terrain.transform.position.x;
                                    newPosition.z = ((row + 1) * terrainSize.z / profile.lightProbesPerRow) - terrainSize.z / profile.lightProbesPerRow / 2f + terrain.transform.position.z;
                                    float sampledHeight = terrain.SampleHeight(newPosition);
                                    newPosition.y = sampledHeight + 2.5f;

                                    List <Vector3> probePositions = new List <Vector3>(lightProbeData.probePositions);
                                    Vector3        position       = lightProbeObject.transform.position - lightProbeData.transform.position; //Translate to local space relative to lpg
                                    probePositions.Add(newPosition);
                                    position += new Vector3(0f, 2.5f, 0f);
                                    probePositions.Add(newPosition);
                                    position += new Vector3(0f, 10f, 0f);
                                    probePositions.Add(newPosition);
                                    lightProbeData.probePositions = probePositions.ToArray();
                                    AddProbe(lightProbeObject.transform.position, lightProbeData);

                                    m_currentProbeCount++;
                                }
                                else
                                {
                                    Vector3 newPosition = lightProbeObject.transform.position - lightProbeData.transform.position;
                                    newPosition.x = ((columns + 1) * terrainSize.x / profile.lightProbesPerRow) - terrainSize.x / profile.lightProbesPerRow / 2f + terrain.transform.position.x;
                                    newPosition.z = ((row + 1) * terrainSize.z / profile.lightProbesPerRow) - terrainSize.z / profile.lightProbesPerRow / 2f + terrain.transform.position.z;
                                    float sampledHeight = terrain.SampleHeight(newPosition);
                                    newPosition.y = sampledHeight + 2.5f;

                                    List <Vector3> probePositions = new List <Vector3>(lightProbeData.probePositions);
                                    Vector3        position       = lightProbeObject.transform.position - lightProbeData.transform.position; //Translate to local space relative to lpg

                                    if (sampledHeight > seaLevel)
                                    {
                                        probePositions.Add(newPosition);
                                        position += new Vector3(0f, 2.5f, 0f);
                                        probePositions.Add(newPosition);
                                        position += new Vector3(0f, 10f, 0f);
                                        probePositions.Add(newPosition);
                                        lightProbeData.probePositions = probePositions.ToArray();
                                        AddProbe(lightProbeObject.transform.position, lightProbeData);

                                        m_currentProbeCount++;
                                    }
                                }
                            }
                        }

                        EditorUtility.ClearProgressBar();
                    }

                    lightProbeObject.transform.SetParent(lightParentObject.transform);
                }
            }
        }