// Use this for initialization
    void Awake()
    {
        #region Initialise
        // This line just gets the starting time of the generation so that the total generation time
        // can be recorded and displayed
        float generationStartTime = Time.realtimeSinceStartup;

        RuntimeSampleHelper.RemoveDefaultCamera();
        RuntimeSampleHelper.RemoveDefaultLight();

        // We're using some old trees in this demo, which don't like anti-aliasing
        QualitySettings.antiAliasing = 0;

        // Get a link to the LBLandscape script
        landscape = this.GetComponent <LBLandscape>();

        if (landscape == null)
        {
            Debug.Log("Cannot find LBLandscape script attached to Runtime gameobject");
            return;
        }

        // Update the size
        landscape.size = landscapeSize;
        // Create the terrains
        int terrainNumber = 0;
        #endregion

        #region Create Terrains
        for (float tx = 0f; tx < landscapeSize.x - 1f; tx += terrainWidth)
        {
            for (float ty = 0f; ty < landscapeSize.y - 1f; ty += terrainWidth)
            {
                // Create a new gameobject
                GameObject terrainObj = new GameObject("RuntimeTerrain" + (terrainNumber++).ToString("000"));
                // Create a new gameobject
                // Correctly parent and position the terrain
                terrainObj.transform.parent        = this.transform;
                terrainObj.transform.localPosition = new Vector3(tx, 0f, ty);
                // Add a terrain component
                Terrain newTerrain = terrainObj.AddComponent <Terrain>();
                // Set terrain settings (depending on your situtation, you may need to set more or less than I have in this example)
                newTerrain.heightmapPixelError   = 5f;
                newTerrain.basemapDistance       = 1000f;
                newTerrain.treeDistance          = 750f;
                newTerrain.treeBillboardDistance = 100f;
                newTerrain.detailObjectDistance  = 200f;
                newTerrain.treeCrossFadeLength   = 5f;
                // Set terrain data settings (same as above comment)
                TerrainData newTerrainData = new TerrainData();
                newTerrainData.heightmapResolution = 513;
                newTerrainData.size = new Vector3(terrainWidth, terrainHeight, terrainWidth);
                newTerrainData.SetDetailResolution(1024, 16);
                newTerrain.terrainData = newTerrainData;

                // Set up the terrain collider
                TerrainCollider newTerrainCol = terrainObj.AddComponent <TerrainCollider>();
                newTerrainCol.terrainData = newTerrainData;
            }
        }

        landscape.SetLandscapeTerrains(true);
        landscape.SetDefaultTerrainMaterial();
        #endregion

        #region Create a Stencil
        // Add a new Stencil to the (empty) landscape
        LBStencil lbStencil = LBStencil.CreateStencilInScene(landscape, landscape.gameObject);
        if (lbStencil != null)
        {
            lbStencil.name += "01";

            /// Import PNG files into stencil layers (at runtime) and add as filters.
            lbStencil.layerImportMethod = LBStencil.LayerImportMethod.Grayscale;
            if (lbStencil.ImportTexture("Hills Layer 1", stencilLayerTex1, true))
            {
                // Remove the default first layer
                if (lbStencil.stencilLayerList.Count > 1)
                {
                    lbStencil.stencilLayerList.RemoveAt(0);
                }
            }
        }
        #endregion

        #region Define the Topography
        // NOTE: This sample uses a topography mask. This is not a requirement

        // Create the distance to centre mask using an animation curve
        AnimationCurve distanceToCentreMask = new AnimationCurve();
        distanceToCentreMask.AddKey(0.00f, 0.04f);
        distanceToCentreMask.AddKey(0.30f, 0.03f);
        distanceToCentreMask.AddKey(0.78f, 1.00f);
        distanceToCentreMask.AddKey(1.00f, 1.00f);
        Keyframe[] distanceToCentreMaskKeys = distanceToCentreMask.keys;
        distanceToCentreMaskKeys[0].inTangent  = 0.00f;
        distanceToCentreMaskKeys[0].outTangent = 0.00f;
        distanceToCentreMaskKeys[1].inTangent  = -0.02f;
        distanceToCentreMaskKeys[1].outTangent = -0.02f;
        distanceToCentreMaskKeys[2].inTangent  = 0.01f;
        distanceToCentreMaskKeys[2].outTangent = 0.01f;
        distanceToCentreMaskKeys[3].inTangent  = 0.00f;
        distanceToCentreMaskKeys[3].outTangent = 0.00f;
        distanceToCentreMask = new AnimationCurve(distanceToCentreMaskKeys);

        // Assign the topography mask to the LBLandscape instance
        landscape.distanceToCentreMask = distanceToCentreMask;
        landscape.topographyMaskMode   = LBLandscape.MaskMode.DistanceToCentre;

        // Create the Topography Layers
        // You can mix and match Perlin and Image layers
        landscape.topographyLayersList = new List <LBLayer>();
        if (landscape.topographyLayersList != null)
        {
            // NOTE
            // If you have used the LB Editor to first build a test landscape, the Topography layer
            // can be scripted out and pasted into your runtime script here.

            // Layer Code generated from Landscape Builder at 7:59 AM on ....
            AnimationCurve additiveCurve = new AnimationCurve();

            AnimationCurve subtractiveCurve = new AnimationCurve();

            List <LBLayerFilter> filters = new List <LBLayerFilter>();
            // Add LayerFilter code here
            List <AnimationCurve> imageCurveModifiers = new List <AnimationCurve>();

            List <AnimationCurve> outputCurveModifiers = new List <AnimationCurve>();
            AnimationCurve        OutputCurve1         = new AnimationCurve();
            OutputCurve1.AddKey(0.00f, 0.00f);
            OutputCurve1.AddKey(0.50f, 0.06f);
            OutputCurve1.AddKey(1.00f, 1.00f);
            Keyframe[] OutputCurve1Keys = OutputCurve1.keys;
            OutputCurve1Keys[0].inTangent  = 0.00f;
            OutputCurve1Keys[0].outTangent = 0.00f;
            OutputCurve1Keys[1].inTangent  = 0.50f;
            OutputCurve1Keys[1].outTangent = 0.50f;
            OutputCurve1Keys[2].inTangent  = 4.00f;
            OutputCurve1Keys[2].outTangent = 4.00f;
            OutputCurve1 = new AnimationCurve(OutputCurve1Keys);

            outputCurveModifiers.Add(OutputCurve1);

            List <AnimationCurve> perOctaveCurveModifiers = new List <AnimationCurve>();
            AnimationCurve        PerOctaveCurve1         = new AnimationCurve();
            PerOctaveCurve1.AddKey(0.00f, 0.00f);
            PerOctaveCurve1.AddKey(0.05f, 0.10f);
            PerOctaveCurve1.AddKey(0.45f, 0.90f);
            PerOctaveCurve1.AddKey(0.50f, 1.00f);
            PerOctaveCurve1.AddKey(0.55f, 0.90f);
            PerOctaveCurve1.AddKey(0.95f, 0.10f);
            PerOctaveCurve1.AddKey(1.00f, 0.00f);
            Keyframe[] PerOctaveCurve1Keys = PerOctaveCurve1.keys;
            PerOctaveCurve1Keys[0].inTangent  = 0.00f;
            PerOctaveCurve1Keys[0].outTangent = 0.00f;
            PerOctaveCurve1Keys[1].inTangent  = 2.00f;
            PerOctaveCurve1Keys[1].outTangent = 2.00f;
            PerOctaveCurve1Keys[2].inTangent  = 2.00f;
            PerOctaveCurve1Keys[2].outTangent = 2.00f;
            PerOctaveCurve1Keys[3].inTangent  = 0.00f;
            PerOctaveCurve1Keys[3].outTangent = 0.00f;
            PerOctaveCurve1Keys[4].inTangent  = -2.00f;
            PerOctaveCurve1Keys[4].outTangent = -2.00f;
            PerOctaveCurve1Keys[5].inTangent  = -2.00f;
            PerOctaveCurve1Keys[5].outTangent = -2.00f;
            PerOctaveCurve1Keys[6].inTangent  = 0.00f;
            PerOctaveCurve1Keys[6].outTangent = 0.00f;
            PerOctaveCurve1 = new AnimationCurve(PerOctaveCurve1Keys);

            perOctaveCurveModifiers.Add(PerOctaveCurve1);

            AnimationCurve mapPathBlendCurve = new AnimationCurve();
            mapPathBlendCurve.AddKey(0.00f, 0.00f);
            mapPathBlendCurve.AddKey(1.00f, 1.00f);
            Keyframe[] mapPathBlendCurveKeys = mapPathBlendCurve.keys;
            mapPathBlendCurveKeys[0].inTangent  = 0.00f;
            mapPathBlendCurveKeys[0].outTangent = 0.00f;
            mapPathBlendCurveKeys[1].inTangent  = 0.00f;
            mapPathBlendCurveKeys[1].outTangent = 0.00f;
            mapPathBlendCurve = new AnimationCurve(mapPathBlendCurveKeys);

            AnimationCurve mapPathHeightCurve = new AnimationCurve();
            mapPathHeightCurve.AddKey(0.00f, 1.00f);
            mapPathHeightCurve.AddKey(1.00f, 1.00f);
            Keyframe[] mapPathHeightCurveKeys = mapPathHeightCurve.keys;
            mapPathHeightCurveKeys[0].inTangent  = 0.00f;
            mapPathHeightCurveKeys[0].outTangent = 0.00f;
            mapPathHeightCurveKeys[1].inTangent  = 0.00f;
            mapPathHeightCurveKeys[1].outTangent = 0.00f;
            mapPathHeightCurve = new AnimationCurve(mapPathHeightCurveKeys);

            LBLayer lbBaseLayer01 = new LBLayer();
            if (lbBaseLayer01 != null)
            {
                lbBaseLayer01.type                   = LBLayer.LayerType.PerlinBase;
                lbBaseLayer01.preset                 = LBLayer.LayerPreset.MountainPeaksBase;
                lbBaseLayer01.layerTypeMode          = LBLayer.LayerTypeMode.Add;
                lbBaseLayer01.noiseTileSize          = 1000;
                lbBaseLayer01.noiseOffsetX           = 0;
                lbBaseLayer01.noiseOffsetZ           = 0;
                lbBaseLayer01.octaves                = 7;
                lbBaseLayer01.downscaling            = 1;
                lbBaseLayer01.lacunarity             = 1.75f;
                lbBaseLayer01.gain                   = 0.475f;
                lbBaseLayer01.additiveAmount         = 0.5f;
                lbBaseLayer01.subtractiveAmount      = 0.2f;
                lbBaseLayer01.additiveCurve          = additiveCurve;
                lbBaseLayer01.subtractiveCurve       = subtractiveCurve;
                lbBaseLayer01.removeBaseNoise        = true;
                lbBaseLayer01.addMinHeight           = false;
                lbBaseLayer01.addHeight              = 0f;
                lbBaseLayer01.restrictArea           = false;
                lbBaseLayer01.areaRect               = new Rect(0, 0, 1000, 1000);
                lbBaseLayer01.interpolationSmoothing = 0;
                //lbBaseLayer01.heightmapImage = heightmapImage;
                lbBaseLayer01.imageHeightScale        = 1f;
                lbBaseLayer01.imageCurveModifiers     = imageCurveModifiers;
                lbBaseLayer01.filters                 = filters;
                lbBaseLayer01.isDisabled              = false;
                lbBaseLayer01.showLayer               = false;
                lbBaseLayer01.showAdvancedSettings    = false;
                lbBaseLayer01.showCurvesAndFilters    = true;
                lbBaseLayer01.showAreaHighlighter     = false;
                lbBaseLayer01.detailSmoothRate        = 0f;
                lbBaseLayer01.areaBlendRate           = 0.5f;
                lbBaseLayer01.downscaling             = 1;
                lbBaseLayer01.warpAmount              = 0f;
                lbBaseLayer01.warpOctaves             = 1;
                lbBaseLayer01.outputCurveModifiers    = outputCurveModifiers;
                lbBaseLayer01.perOctaveCurveModifiers = perOctaveCurveModifiers;
                lbBaseLayer01.heightScale             = 0.75f;
                lbBaseLayer01.minHeight               = 0f;
                lbBaseLayer01.imageSource             = LBLayer.LayerImageSource.Default;
                lbBaseLayer01.imageRepairHoles        = false;
                lbBaseLayer01.threshholdRepairHoles   = 0f;
                lbBaseLayer01.mapPathBlendCurve       = mapPathBlendCurve;
                lbBaseLayer01.mapPathHeightCurve      = mapPathHeightCurve;
                lbBaseLayer01.mapPathAddInvert        = false;
                lbBaseLayer01.floorOffsetY            = 0f;
                // Add LBMapPath code here
                // lbBaseLayer01.lbPath = lbPath;
                // lbBaseLayer01.lbMapPath = lbMapPath;

                // NOTE Add the new layer to the landscape meta-data
                landscape.topographyLayersList.Add(lbBaseLayer01);
            }
        }

        #endregion

        // Create the terrain topographies
        landscape.ApplyTopography(false, true);

        // NOTE
        // If you have used the LB Editor to first build a test path in a landscape, the path points can be scripted
        // out and pasted into your runtime script

        #region LBMapPath Map Path
        // LBMapPath generated from Landscape Builder at 3:10 PM on Sunday, October 01, 2017
        LBMapPath lbMapPath = LBMapPath.CreateMapPath(landscape, landscape.gameObject);
        if (lbMapPath != null)
        {
            lbMapPath.name = "Map Path";
            if (lbMapPath.lbPath != null)
            {
                lbMapPath.lbPath.pathName           = "Map Path";
                lbMapPath.mapResolution             = 1;
                lbMapPath.lbPath.blendStart         = true;
                lbMapPath.lbPath.blendEnd           = true;
                lbMapPath.lbPath.pathResolution     = 2f;
                lbMapPath.lbPath.closedCircuit      = false;
                lbMapPath.lbPath.edgeBlendWidth     = 0f;
                lbMapPath.lbPath.removeCentre       = false;
                lbMapPath.lbPath.leftBorderWidth    = 0f;
                lbMapPath.lbPath.rightBorderWidth   = 0f;
                lbMapPath.lbPath.snapToTerrain      = true;
                lbMapPath.lbPath.heightAboveTerrain = 0f;
                lbMapPath.lbPath.zoomOnFind         = true;
                lbMapPath.lbPath.findZoomDistance   = 50f;
                // Mesh options
                lbMapPath.lbPath.isMeshLandscapeUV       = false;
                lbMapPath.lbPath.meshUVTileScale         = new Vector2(1, 1);
                lbMapPath.lbPath.meshYOffset             = 0.08f;
                lbMapPath.lbPath.meshEdgeSnapToTerrain   = true;
                lbMapPath.lbPath.meshSnapType            = LBPath.MeshSnapType.BothEdges;
                lbMapPath.lbPath.meshIsDoubleSided       = false;
                lbMapPath.lbPath.meshIncludeEdges        = false;
                lbMapPath.lbPath.meshIncludeWater        = false;
                lbMapPath.lbPath.meshSaveToProjectFolder = false;
                lbMapPath.meshMaterial = path1meshMaterial;
                // Path Points
                lbMapPath.lbPath.positionList.Add(new Vector3(631.6624f, 23.52699f, 825.2574f));
                lbMapPath.lbPath.positionList.Add(new Vector3(615.8184f, 9.507171f, 763.9471f));
                lbMapPath.lbPath.positionList.Add(new Vector3(592.5421f, 4.510101f, 721.7316f));
                lbMapPath.lbPath.positionList.Add(new Vector3(600.6003f, 2.589149f, 679.3673f));
                lbMapPath.lbPath.positionList.Add(new Vector3(620.8919f, 2.475228f, 658.526f));
                lbMapPath.lbPath.positionList.Add(new Vector3(599.6022f, 2.838308f, 605.2884f));
                lbMapPath.lbPath.positionList.Add(new Vector3(575.0403f, 2.714737f, 555.6046f));
                lbMapPath.lbPath.positionList.Add(new Vector3(560.4745f, 2.838308f, 472.1874f));
                lbMapPath.lbPath.positionList.Add(new Vector3(570.2177f, 3.09073f, 444.6886f));
                lbMapPath.lbPath.positionList.Add(new Vector3(570.2177f, 3.299063f, 387.1046f));
                lbMapPath.lbPath.positionList.Add(new Vector3(600.3734f, 4.613719f, 311.1418f));
                lbMapPath.lbPath.positionList.Add(new Vector3(610.5876f, 6.345493f, 293.1662f));
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(11.32066f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.widthList.Add(14f);
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(638.2852f, 23.52699f, 823.5834f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(622.2536f, 9.507171f, 761.4589f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(599.409f, 4.510101f, 720.4888f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(606.8383f, 2.589149f, 682.5374f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(627.8883f, 2.475228f, 658.7487f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(604.7557f, 2.838308f, 602.9471f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(581.7473f, 2.714737f, 553.6004f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(567.473f, 2.838308f, 472.0406f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(577.1524f, 3.09073f, 445.6413f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(577.0537f, 3.299063f, 388.6086f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(606.7752f, 4.613719f, 313.9633f));
                lbMapPath.lbPath.positionListLeftEdge.Add(new Vector3(616.454f, 6.345493f, 296.91f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(625.0396f, 23.52699f, 826.9315f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(609.3831f, 9.507171f, 766.4353f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(585.6751f, 4.510101f, 722.9744f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(594.3624f, 2.589149f, 676.1973f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(613.8955f, 2.475228f, 658.3033f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(594.4488f, 2.838308f, 607.6296f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(568.3334f, 2.714737f, 557.6088f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(553.4761f, 2.838308f, 472.3342f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(563.2829f, 3.09073f, 443.736f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(563.3816f, 3.299063f, 385.6005f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(593.9716f, 4.613719f, 308.3203f));
                lbMapPath.lbPath.positionListRightEdge.Add(new Vector3(604.7213f, 6.345493f, 289.4224f));
                lbMapPath.minPathWidth = lbMapPath.lbPath.GetMinWidth();
                lbMapPath.lbPath.RefreshPathHeights(landscape);
                // Create Mesh for Path
                if (lbMapPath.lbPath.CreateMeshFromPath(landscape))
                {
                    Vector3   meshPosition  = new Vector3(0f, lbMapPath.lbPath.meshYOffset, 0f);
                    Transform meshTransform = LBMeshOperations.AddMeshToScene(lbMapPath.lbPath.lbMesh, meshPosition, lbMapPath.lbPath.pathName + " Mesh", lbMapPath.transform, lbMapPath.meshMaterial, true, true);
                    if (meshTransform != null)
                    {
                    }
                }
            }
        }
        #endregion

        // Create a list of LBTerrainTexture objects
        // These contain the textures and normal maps but also the rules for applying them to the terrain
        landscape.terrainTexturesList = new List <LBTerrainTexture>();

        // Populate the list by creating temporary LBTerrainTexture objects and adjusting their settings,
        // then adding each one into the list

        // Update the textures
        LBTerrainTexture tempTerrainTexture = new LBTerrainTexture();
        if (tempTerrainTexture != null)
        {
            // Forest Floor
            tempTerrainTexture.texture       = texture1;
            tempTerrainTexture.normalMap     = texture1NM;
            tempTerrainTexture.tileSize      = Vector2.one * 15f;
            tempTerrainTexture.useNoise      = false;
            tempTerrainTexture.texturingMode = LBTerrainTexture.TexturingMode.ConstantInfluence;
            tempTerrainTexture.strength      = 0.04f;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Rock Layered
            tempTerrainTexture                = new LBTerrainTexture();
            tempTerrainTexture.texture        = texture2;
            tempTerrainTexture.normalMap      = texture2NM;
            tempTerrainTexture.tileSize       = Vector2.one * 100f;
            tempTerrainTexture.texturingMode  = LBTerrainTexture.TexturingMode.HeightAndInclination;
            tempTerrainTexture.minHeight      = 400f / terrainHeight;
            tempTerrainTexture.maxHeight      = 1000f / terrainHeight;
            tempTerrainTexture.minInclination = 30f;
            tempTerrainTexture.maxInclination = 90f;
            tempTerrainTexture.useNoise       = true;
            tempTerrainTexture.noiseTileSize  = 100f;
            tempTerrainTexture.strength       = 1f;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Rock1
            tempTerrainTexture                = new LBTerrainTexture();
            tempTerrainTexture.texture        = texture3;
            tempTerrainTexture.normalMap      = texture3NM;
            tempTerrainTexture.tileSize       = Vector2.one * 100f;
            tempTerrainTexture.texturingMode  = LBTerrainTexture.TexturingMode.HeightAndInclination;
            tempTerrainTexture.minHeight      = 10f / terrainHeight;
            tempTerrainTexture.maxHeight      = 1000f / terrainHeight;
            tempTerrainTexture.minInclination = 30f;
            tempTerrainTexture.maxInclination = 60f;
            tempTerrainTexture.useNoise       = true;
            tempTerrainTexture.noiseTileSize  = 100f;
            tempTerrainTexture.strength       = 1f;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // CliffBlue
            tempTerrainTexture               = new LBTerrainTexture();
            tempTerrainTexture.texture       = texture4;
            tempTerrainTexture.normalMap     = texture4NM;
            tempTerrainTexture.tileSize      = Vector2.one * 100f;
            tempTerrainTexture.texturingMode = LBTerrainTexture.TexturingMode.Height;
            tempTerrainTexture.minHeight     = 100f / terrainHeight;
            tempTerrainTexture.maxHeight     = 1000f / terrainHeight;
            tempTerrainTexture.useNoise      = true;
            tempTerrainTexture.noiseTileSize = 10f;
            tempTerrainTexture.strength      = 0.5f;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Good Dirt - FUTURE generate Map at runtime from slightly wider path and texture edges
            //tempTerrainTexture = new LBTerrainTexture();
            //tempTerrainTexture.texture = texture5;
            //tempTerrainTexture.normalMap = texture5NM;
            //tempTerrainTexture.tileSize = Vector2.one * 10f;
            //tempTerrainTexture.texturingMode = LBTerrainTexture.TexturingMode.Map;
            //tempTerrainTexture.map = ....
            //tempTerrainTexture.mapIsPath = true;
            //tempTerrainTexture.useAdvancedMapTolerance = false;
            //tempTerrainTexture.mapInverse = false;
            //tempTerrainTexture.useNoise = false;
            //tempTerrainTexture.strength = 1f;
            //landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Texture the terrains
            landscape.ApplyTextures(true, true);
        }

        // Add a tree type
        LBTerrainTree terrainTree1 = new LBTerrainTree();
        if (terrainTree1 != null && treePrefab1 != null)
        {
            // Set tree type options as required. See LBTerrainTree class constructor for default settings
            terrainTree1.prefab            = treePrefab1.gameObject;
            terrainTree1.maxTreesPerSqrKm  = 140;
            terrainTree1.minScale          = 2f;
            terrainTree1.maxScale          = 3f;
            terrainTree1.treeScalingMode   = LBTerrainTree.TreeScalingMode.RandomScaling;
            terrainTree1.lockWidthToHeight = true;
            terrainTree1.treePlacingMode   = LBTerrainTree.TreePlacingMode.HeightAndInclination;
            terrainTree1.minInclination    = 0f;
            terrainTree1.maxInclination    = 30f;
            terrainTree1.minHeight         = 0f;
            terrainTree1.maxHeight         = 200f / terrainHeight;
            terrainTree1.useNoise          = false;

            //// Create a new filter, which will be used for the Stencil Layer
            //// This demonstrates how to apply a stencil layer to the placement of trees
            //LBFilter lbFilterTree = LBFilter.CreateFilter(lbStencil, "Hills Layer 1", true);

            //if (lbFilterTree != null)
            //{
            //    // If the list of filters isn't defined, create an empty list
            //    if (terrainTree1.filterList == null) { terrainTree1.filterList = new List<LBFilter>(); }

            //    // Add the Stencil Layer to the list of Tree Filters
            //    terrainTree1.filterList.Add(lbFilterTree);
            //}

            // Add the tree type configuration to the landscape
            landscape.terrainTreesList.Add(terrainTree1);
        }

        LBTerrainTree terrainTree2 = new LBTerrainTree();
        if (terrainTree2 != null && treePrefab1 != null)
        {
            // Set tree type options as required. See LBTerrainTree class constructor for default settings
            terrainTree2.prefab            = treePrefab2.gameObject;
            terrainTree2.maxTreesPerSqrKm  = 140;
            terrainTree2.minScale          = 2f;
            terrainTree2.maxScale          = 3f;
            terrainTree2.treeScalingMode   = LBTerrainTree.TreeScalingMode.RandomScaling;
            terrainTree2.lockWidthToHeight = true;
            terrainTree2.treePlacingMode   = LBTerrainTree.TreePlacingMode.HeightAndInclination;
            terrainTree2.minInclination    = 0f;
            terrainTree2.maxInclination    = 30f;
            terrainTree2.minHeight         = 0f;
            terrainTree2.maxHeight         = 200f / terrainHeight;
            terrainTree2.useNoise          = false;

            // Add the tree type configuration to the landscape
            landscape.terrainTreesList.Add(terrainTree2);
        }

        // Populate the landscape with the trees
        landscape.treesHaveColliders = true;
        landscape.treePlacementSpeed = LBTerrainTree.TreePlacementSpeed.FastPlacement;
        landscape.ApplyTrees(true, true);

        // Add some rock prefabs to the landscape
        LBLandscapeMesh lbLandscapeMesh = new LBLandscapeMesh();
        if (lbLandscapeMesh != null && rockPrefab != null)
        {
            lbLandscapeMesh.usePrefab = true;
            lbLandscapeMesh.prefab    = rockPrefab;
            // Set mesh options as required. See LBLandscapeMesh class constructor for default settings
            lbLandscapeMesh.maxMeshes       = 50;
            lbLandscapeMesh.meshPlacingMode = LBLandscapeMesh.MeshPlacingMode.ConstantInfluence;
            // Sink the rocks into the ground by 0.5m
            lbLandscapeMesh.offset = new Vector3(0f, -0.5f, 0f);
            // Group the rocks together
            //lbLandscapeMesh.isClustered = true;
            //lbLandscapeMesh.clusterDensity = 0.1f;
            //lbLandscapeMesh.clusterDistance = 10f;

            landscape.landscapeMeshList.Add(lbLandscapeMesh);

            landscape.meshPlacementSpeed = LBLandscapeMesh.MeshPlacementSpeed.FastPlacement;
            //landscape.ApplyMeshes(true, true);
        }

        // Get the first Camera Animator in the scene, snap the camera path to the new terrain,
        // and start moving the camera along the camera path.
        LBCameraAnimator lbCameraAnimator = LBCameraAnimator.GetFirstCameraAnimatorInLandscape(landscape);
        if (lbCameraAnimator == null)
        {
            Debug.LogWarning("GetFirstCameraAnimatorInLandscape returned null");
        }
        else
        {
            if (lbMapPath != null)
            {
                if (!lbCameraAnimator.cameraPath.ImportMapPathPoints(lbMapPath))
                {
                    Debug.LogWarning("Could not make camera animator travel along new Map Path.");
                }
            }

            // Get the LBPath instance which contains the points along the camera path
            LBPath lbPath = lbCameraAnimator.cameraPath.lbPath;
            if (lbPath == null)
            {
                Debug.LogWarning("Could not find the camera path instance for the animator");
            }
            else
            {
                // Optionally update the path points to match the terrain
                lbPath.heightAboveTerrain = 5f;
                lbPath.snapToTerrain      = true;
                lbPath.RefreshPathHeights(landscape);

                // Start the camera moving from the start of the path.
                lbCameraAnimator.BeginAnimation(true, 0f);
            }
        }

        // Display the total time taken to generate the landscape (usually for debugging purposes)
        Debug.Log("Time taken to generate landscape: " + (Time.realtimeSinceStartup - generationStartTime).ToString("00.00") + " seconds.");
    }
예제 #2
0
        /// <summary>
        /// Load a template but delay short period of time after updating
        /// the infoPanel text to force it to be displayed
        /// For URP/LWRP/HDRP all trees will be forced to be billboarded
        /// as currently we are only using built-in SRP trees.
        /// </summary>
        /// <param name="templateNumber"></param>
        /// <returns></returns>
        IEnumerator LoadTemplateWithUIDelay(int templateNumber)
        {
            bool showSRPWarning = false;

            if (lbTemplates != null)
            {
                int numTemplates = lbTemplates.Length;

                if (templateNumber < numTemplates)
                {
                    LBTemplate lbTemplate = lbTemplates[templateNumber];

                    if (lbTemplate != null)
                    {
                        // Disable buttons
                        EnableButton(quality1Button, false);
                        EnableButton(quality2Button, false);
                        EnableButton(quality3Button, false);
                        EnableButton(quality4Button, false);
                        EnableButton(infoButton, false);
                        EnableButton(gpuButton, false);
                        DisplayBackgroundPanel(true);

                        currentTemplateName = lbTemplate.name;

                        SetInfoTitle("Loading Template... PLEASE WAIT");

                        string infoText = "Applying template... ";

                        SetInfoText(infoText);
                        DisplayInfoPanel(true);
                        yield return(new WaitForSeconds(0.1f));

                        // Remove any camera animators
                        LBCameraAnimator.RemoveCameraAnimatorsFromScene(lbLandscape, false);
                        yield return(new WaitForSeconds(0.1f));

                        // if LBLighting is in the scene, remove all references to terrains to
                        // prevent errors when the current landscape is deleted.
                        LBLighting lbLighting = GameObject.FindObjectOfType <LBLighting>();
                        if (lbLighting != null)
                        {
                            lbLighting.ClearAllTerrains();
                        }

                        if (lbLandscape != null)
                        {
                            DestroyImmediate(lbLandscape.gameObject);
                        }
                        lbLandscape = lbTemplate.CreateLandscapeFromTemplate("DemoLandscape");
                        Camera mainCamera = Camera.main;

                        if (mainCamera != null)
                        {
                            mainCamera.transform.position = new Vector3(2000f, 2000f, 0f);
                            mainCamera.transform.LookAt(lbLandscape.transform);
                        }

                        // Currently, when applying template ignore water if LWRP, URP or HDRP are enabled
                        // This could be updated if we had a LWRP/HDRP-compatible water asset
                        if (lbTemplate.ApplyTemplateToLandscape(lbLandscape, ignoreStartPosition, true, (isURP || isLWRP || isHDRP) ? null : waterPrefab, true))
                        {
                            infoText += "DONE\n\n";
                            SetInfoText(infoText);
                            yield return(new WaitForSeconds(0.1f));

                            lbLandscape.showTiming = false;
                            lbLandscape.SetLandscapeTerrains(true);

                            // Build the landscape
                            int numTerrains = (lbLandscape.landscapeTerrains == null ? 0 : lbLandscape.landscapeTerrains.Length);
                            if (numTerrains > 0)
                            {
                                // Our older templates don't use GPU for Topography and Path. If it is fully capable
                                // of using the GPU, list it here.
                                bool isModernTemplate = lbTemplate.name.StartsWith("DemoStoneCottage");

                                // Override the template GPU settings
                                lbLandscape.useGPUTopography = isModernTemplate ? enableGPU : false;
                                lbLandscape.useGPUTexturing  = enableGPU;
                                lbLandscape.useGPUGrass      = enableGPU;
                                lbLandscape.useGPUPath       = isModernTemplate ? enableGPU : false;

                                // Check for URP/LWRP/HDRP or do we need to create a default material for U2019.2.0 or newer
                                if (isURP || isLWRP || isHDRP || is201920Plus)
                                {
                                    float   pixelError = 0f;
                                    Terrain terrain    = null;
                                    LBLandscape.TerrainMaterialType terrainMaterialType = isURP ? LBLandscape.TerrainMaterialType.URP : (isLWRP ? LBLandscape.TerrainMaterialType.LWRP : (terrainMaterialType = isHDRP ? LBLandscape.TerrainMaterialType.HDRP : LBLandscape.TerrainMaterialType.BuiltInStandard));

                                    for (int tIdx = 0; tIdx < numTerrains; tIdx++)
                                    {
                                        terrain = lbLandscape.landscapeTerrains[tIdx];
                                        lbLandscape.SetTerrainMaterial(terrain, tIdx, (tIdx == numTerrains - 1), terrain.terrainData.size.x, ref pixelError, terrainMaterialType);

                                        // For URP/LWRP/HDRP all trees will be forced to be billboarded
                                        // as currently we are only using built-in SRP trees.
                                        if (isURP || isLWRP || isHDRP)
                                        {
                                            // Force all trees to be billboards
                                            terrain.treeBillboardDistance   = 0f;
                                            terrain.treeMaximumFullLODCount = 0;
                                            showSRPWarning = true;
                                        }
                                    }
                                }

                                // These are the cut-down versions without progress bars and minimal validation
                                infoText += "Building Topography" + (lbLandscape.useGPUTopography ? " (GPU)..." : "...");
                                SetInfoText(infoText);
                                yield return(new WaitForSeconds(0.1f));

                                lbLandscape.ApplyTopography(true, true);
                                infoText += "DONE\n\n";
                                infoText += "Adding Textures" + (lbLandscape.useGPUTexturing ? " (GPU)..." : "...");
                                SetInfoText(infoText);
                                yield return(new WaitForSeconds(0.1f));

                                lbLandscape.ApplyTextures(true, true);
                                infoText += "DONE\n\n";
                                infoText += "Placing Trees... ";
                                SetInfoText(infoText);
                                yield return(new WaitForSeconds(0.1f));

                                lbLandscape.ApplyTrees(true, true);
                                infoText += "DONE\n\n";
                                infoText += "Placing Grass" + (lbLandscape.useGPUGrass ? " (GPU)..." : "...");
                                SetInfoText(infoText);
                                yield return(new WaitForSeconds(0.1f));

                                lbLandscape.ApplyGrass(true, true);
                                infoText += "DONE\n\n";
                                SetInfoText(infoText);
                                yield return(new WaitForSeconds(0.1f));

                                if (lbLandscape.lbGroupList != null && lbLandscape.lbGroupList.Count > 0)
                                {
                                    infoText += "Placing Groups" + (lbLandscape.useGPUTopography ? " (GPU)..." : "...");
                                    SetInfoText(infoText);
                                    yield return(new WaitForSeconds(0.1f));

                                    lbLandscape.ApplyGroups(false, false);
                                }

                                // Apply lighting last as it needs the Camera Paths (and Animator camera to set up WeatherFX)
                                if (lbTemplate.isLBLightingIncluded)
                                {
                                    infoText += "Applying lighting... ";
                                    SetInfoText(infoText);
                                    yield return(new WaitForSeconds(0.1f));

                                    //if (lbLighting != null) { DestroyImmediate(lbLighting.gameObject); }

                                    if (lbLighting == null)
                                    {
                                        // If LBLighting isn't already in the scene, add it.
                                        lbLighting = LBLighting.AddLightingToScene(true);
                                    }

                                    if (lbLighting != null)
                                    {
                                        // Restore the lighting settings from the template
                                        lbTemplate.ApplyLBLightingSettings(lbLandscape, ref lbLighting, mainCamera, true);
                                    }
                                    infoText += "DONE\n\n";
                                    SetInfoText(infoText);
                                    yield return(new WaitForSeconds(0.1f));

                                    // Prior to Unity 5.4, ImageFX and/or camera clear flags are not updated correctly
                                    // when the WeatherFX with celestials is added to the scene after a configuration without
                                    // celestials. The workaround, is to force the GameView to repaint or be re-initalised.
                                    // To be effective, a "reasonable" delay is required between switching away from Game view
                                    // and back. The exact cause of the issue is unknown...
                                    #if !UNITY_5_4_OR_NEWER && UNITY_EDITOR
                                    if (lbLighting.useCelestials)
                                    {
                                        bool wasMaximized = LBEditorHelper.GameViewMaximize(this.GetType(), false);
                                        LBEditorHelper.ShowSceneView(this.GetType(), true);
                                        yield return(new WaitForSeconds(0.5f));

                                        LBEditorHelper.GameViewMaximize(this.GetType(), wasMaximized);
                                    }
                                    #endif
                                }

                                // Find the first animation and start it (there should be only one in a demo template)
                                LBCameraAnimator lbCameraAnimator = LBCameraAnimator.GetFirstCameraAnimatorInLandscape(lbLandscape);
                                if (lbCameraAnimator != null)
                                {
                                    if (lbTemplate.name.StartsWith("FPS Forest Demo"))
                                    {
                                        // This uses the old Unity 4 trees which don't work so well with anti-aliasing
                                        QualitySettings.antiAliasing = 0;

                                        if (lbCameraAnimator.animatorCamera != null)
                                        {
                                            lbCameraAnimator.SetMoveSpeed(2f);
                                            lbCameraAnimator.animatorCamera.renderingPath = RenderingPath.Forward;
                                            lbCameraAnimator.animateSpeed = false;
                                        }
                                    }
                                    else if (lbTemplate.name.StartsWith("DemoStoneCottage"))
                                    {
                                        lbCameraAnimator.minMoveSpeed = 1f;
                                        lbCameraAnimator.maxMoveSpeed = 3f;
                                        lbCameraAnimator.animateSpeed = true;
                                    }
                                    else
                                    {
                                        lbCameraAnimator.animateSpeed = true;
                                    }

                                    // Reset LBImageFX timing so clouds always appear the same
                                    if (lbCameraAnimator.animatorCamera != null)
                                    {
                                        LBImageFX lbImageFX = lbCameraAnimator.animatorCamera.GetComponent <LBImageFX>();
                                        if (lbImageFX != null)
                                        {
                                            //Debug.Log("LBDemoLoader.LoadTemplateWithUIDelay - Resetting LBImageFX cloud positions");
                                            lbImageFX.ResetCloudPosition();
                                        }
                                    }

                                    //Debug.Log("LBDemoLoader " + lbTemplate.name + " renderpath: " + lbCameraAnimator.animatorCamera.renderingPath);

                                    lbCameraAnimator.pauseAtEndDuration = 999f;
                                    lbCameraAnimator.BeginAnimation(true, 0f);
                                }
                                else
                                {
                                    Debug.LogWarning("LBDemoLoader.LoadTemplateWithUIDelay - Couldn't find a camera animator in the demo template");
                                }
                            }
                        }

                        // Re-enable buttons
                        EnableButton(quality1Button, true);
                        EnableButton(quality2Button, true);
                        EnableButton(quality3Button, true);
                        EnableButton(quality4Button, true);
                        EnableButton(infoButton, true);
                        EnableButton(gpuButton, true);
                        UpdateInfoButtonText("Show Info");
                    }
                }
            }

            if (showSRPWarning)
            {
                SetInfoTitle("SRP WARNING");
                SetInfoText("This demo scene is designed for the built-in RP.\n\nSee SRP folder for into on URP and HDRP");
            }
            else
            {
                DisplayInfoPanel(false);
            }

            DisplayBackgroundPanel(false);
        }
    // Use this for initialization
    void Awake()
    {
        #region Initialise
        // This line just gets the starting time of the generation so that the total generation time
        // can be recorded and displayed
        float generationStartTime = Time.realtimeSinceStartup;

        RuntimeSampleHelper.RemoveDefaultCamera();
        RuntimeSampleHelper.RemoveDefaultLight();

        // Get a link to the LBLandscape script
        landscape = this.GetComponent <LBLandscape>();

        if (landscape == null)
        {
            Debug.Log("Cannot find LBLandscape script attached to Runtime gameobject");
            return;
        }

        // Update the size
        landscape.size = landscapeSize;

        #endregion

        #region Create the terrains
        int terrainNumber = 0;

        for (float tx = 0f; tx < landscapeSize.x - 1f; tx += 2000f)
        {
            for (float ty = 0f; ty < landscapeSize.y - 1f; ty += 2000f)
            {
                // Create a new gameobject
                GameObject terrainObj = new GameObject("Runtime Terrain " + (terrainNumber++).ToString("000"));

                // Correctly parent and position the terrain
                terrainObj.transform.parent        = this.transform;
                terrainObj.transform.localPosition = new Vector3(tx, 0f, ty);

                // Add a terrain component
                Terrain newTerrain = terrainObj.AddComponent <Terrain>();

                // Set terrain settings (depending on your situtation, you may need to set more or less than I have in this example)
                newTerrain.heightmapPixelError   = 1;
                newTerrain.basemapDistance       = 5000f;
                newTerrain.treeDistance          = 5000f;
                newTerrain.treeBillboardDistance = 100f;
                newTerrain.detailObjectDistance  = 150f;
                newTerrain.treeCrossFadeLength   = 25f;

                newTerrain.groupingID       = 100; // default is 0
                newTerrain.allowAutoConnect = true;

                // Set terrain data settings (same as above comment)
                TerrainData newTerrainData = new TerrainData();

                // One thing to note here is that modfiying the heightmap resolution not only clears all terrain height data,
                // it also scales up or down the size of the terrain. So you should always set the heightmap resolution
                // BEFORE you set the terrain size
                newTerrainData.heightmapResolution = 513;
                newTerrainData.size = Vector3.one * 2000f;
                newTerrainData.SetDetailResolution(1024, 16);
                newTerrain.terrainData = newTerrainData;

                // Set up the terrain collider
                TerrainCollider newTerrainCol = terrainObj.AddComponent <TerrainCollider>();
                newTerrainCol.terrainData = newTerrainData;
            }
        }
        #endregion

        landscape.SetLandscapeTerrains(true);
        terrainHeight = landscape.GetLandscapeTerrainHeight();

        landscape.SetDefaultTerrainMaterial();

        #region Add a new Stencil to the (empty) landscape
        LBStencil lbStencil = LBStencil.CreateStencilInScene(landscape, landscape.gameObject);
        if (lbStencil != null)
        {
            lbStencil.name += "01";

            /// Import PNG files into stencil layers (at runtime) and add as filters.
            lbStencil.layerImportMethod = LBStencil.LayerImportMethod.Grayscale;
            if (lbStencil.ImportTexture("Hills Layer 1", stencilLayerTex1, true))
            {
                // Remove the default first layer
                if (lbStencil.stencilLayerList.Count > 1)
                {
                    lbStencil.stencilLayerList.RemoveAt(0);
                }
            }
        }
        #endregion

        // NOTE: This sample uses a topography mask. This is not a requirement

        // Create the distance to centre mask using an animation curve
        AnimationCurve distanceToCentreMask = new AnimationCurve();
        int            keyInt = distanceToCentreMask.AddKey(0f, 1f);
        keyInt = distanceToCentreMask.AddKey(0.529f, 0.959f);
        keyInt = distanceToCentreMask.AddKey(1f, 0f);
        Keyframe[] curveKeys = distanceToCentreMask.keys;
        curveKeys[0].inTangent  = 0f;
        curveKeys[0].outTangent = 0f;
        curveKeys[1].inTangent  = -0.25f;
        curveKeys[1].outTangent = -0.25f;
        curveKeys[2].inTangent  = 0f;
        curveKeys[2].outTangent = 0f;
        distanceToCentreMask    = new AnimationCurve(curveKeys);

        // Assign the topography mask to the LBLandscape instance
        landscape.distanceToCentreMask = distanceToCentreMask;
        if (IsMaskingOn)
        {
            landscape.topographyMaskMode = LBLandscape.MaskMode.DistanceToCentre;
        }
        else
        {
            landscape.topographyMaskMode = LBLandscape.MaskMode.None;
        }
        landscape.maskWarpAmount         = 0f;
        landscape.maskNoiseTileSize      = 10000f;
        landscape.maskNoiseCurveModifier = AnimationCurve.Linear(0f, 0.5f, 1f, 1f);
        landscape.maskNoiseOffsetX       = 0f;
        landscape.maskNoiseOffsetY       = 0f;

        // Avoid warning of keyInt not being used.
        if (keyInt == 0)
        {
        }

        // Create the Topography Layers
        // You can mix and match Perlin and Image layers
        landscape.topographyLayersList = new List <LBLayer>();
        if (landscape.topographyLayersList != null)
        {
            // Add one or more Base layers
            LBLayer lbBaseLayer1 = new LBLayer();
            if (lbBaseLayer1 != null)
            {
                lbBaseLayer1 = LBLayer.SetLayerFromPreset(LBLayer.LayerPreset.DesertFloorBase);
                landscape.topographyLayersList.Add(lbBaseLayer1);
            }

            // Add one or more Additive layers
            LBLayer lbAdditiveLayer1 = new LBLayer();
            if (lbAdditiveLayer1 != null)
            {
                // You can manually configure a layer, or use a preset then modify it.
                lbAdditiveLayer1 = LBLayer.SetLayerFromPreset(LBLayer.LayerPreset.RollingHillsBase);
                // If using using a different type of preset, must set the type after applying preset
                lbAdditiveLayer1.type = LBLayer.LayerType.PerlinAdditive;
                // Optionally override the preset settings
                //lbAdditiveLayer1.noiseTileSize = 5000f;
                //lbAdditiveLayer1.octaves = 8;
                //lbAdditiveLayer1.lacunarity = 1.92f;
                //lbAdditiveLayer1.gain = 0.45f;
                //lbAdditiveLayer1.warpAmount = 0;
                lbAdditiveLayer1.removeBaseNoise = true;
                lbAdditiveLayer1.heightScale     = 0.35f;
                lbAdditiveLayer1.additiveAmount  = 0.95f;
                lbAdditiveLayer1.additiveCurve   = LBLayer.CreateAdditiveCurve(lbAdditiveLayer1.additiveAmount);
                //lbAdditiveLayer1.perOctaveCurveModifierPresets = new List<LBCurve.CurvePreset>();
                //lbAdditiveLayer1.perOctaveCurveModifierPresets.Add(LBCurve.CurvePreset.DoubleRidged);

                // Create a new topography layer filter, which will be used for the Stencil Layer
                LBLayerFilter lbLayerFilter = LBLayerFilter.CreateLayerFilter(lbStencil, "Hills Layer 1", true);

                if (lbLayerFilter != null)
                {
                    // If the list of filters isn't defined, create an empty list
                    if (lbAdditiveLayer1.filters == null)
                    {
                        lbAdditiveLayer1.filters = new List <LBLayerFilter>();
                    }

                    // Add the Stencil Layer to the list of Topography LayerFilters
                    lbAdditiveLayer1.filters.Add(lbLayerFilter);
                }

                landscape.topographyLayersList.Add(lbAdditiveLayer1);
            }

            // Add a detail layer
            LBLayer lbDetailLayer1 = new LBLayer();
            if (lbDetailLayer1 != null)
            {
                lbDetailLayer1 = LBLayer.SetLayerFromPreset(LBLayer.LayerPreset.HillsDetail);
                landscape.topographyLayersList.Add(lbDetailLayer1);
            }
        }

        // Create the terrain topographies
        landscape.ApplyTopography(false, true);

        // Get the first Camera Animator in the scene, snap the camera path to the new terrain,
        // and start moving the camera along the camera path.
        LBCameraAnimator lbCameraAnimator = LBCameraAnimator.GetFirstCameraAnimatorInLandscape(landscape);
        if (lbCameraAnimator == null)
        {
            Debug.LogWarning("GetFirstCameraAnimatorInLandscape returned null");
        }
        else
        {
            // Get the LBPath instance which contains the points along the camera path
            LBPath lbPath = lbCameraAnimator.cameraPath.lbPath;
            if (lbPath == null)
            {
                Debug.LogWarning("Could not find the camera path instance for the animator");
            }
            else
            {
                // Optionally update the path points to match the terrain
                lbPath.heightAboveTerrain = 15f;
                lbPath.snapToTerrain      = true;
                lbPath.RefreshPathHeights(landscape);

                // Start the camera moving from the start of the path.
                lbCameraAnimator.BeginAnimation(true, 0f);
            }
        }

        // Add some water the scene
        int     numberOfMeshes = 0;
        Vector2 waterSize      = new Vector2(landscape.size.x * 2f, landscape.size.y * 2f);
        // The primary water body is placed in the centre of the landscape
        Vector3 waterPosition = landscape.start + (0.5f * new Vector3(landscape.size.x, 0f, landscape.size.y));

        // Populate the paramaters to pass to AddWaterToScene()
        LBWaterParameters lbWaterParms = new LBWaterParameters();
        lbWaterParms.landscape               = landscape;
        lbWaterParms.landscapeGameObject     = landscape.gameObject;
        lbWaterParms.waterPosition           = waterPosition;
        lbWaterParms.waterSize               = waterSize;
        lbWaterParms.waterIsPrimary          = true;
        lbWaterParms.waterHeight             = waterHeight;
        lbWaterParms.waterPrefab             = waterPrefab;
        lbWaterParms.keepPrefabAspectRatio   = true;
        lbWaterParms.waterResizingMode       = LBWater.WaterResizingMode.StandardAssets;
        lbWaterParms.waterMaxMeshThreshold   = 5000;
        lbWaterParms.waterMainCamera         = Camera.main;
        lbWaterParms.waterCausticsPrefabList = null;
        lbWaterParms.isRiver    = false;
        lbWaterParms.lbLighting = GameObject.FindObjectOfType <LBLighting>();

        LBWater addedWater = LBWaterOperations.AddWaterToScene(lbWaterParms, ref numberOfMeshes);

        if (addedWater == null)
        {
            Debug.LogWarning("Could not add water to scene");
        }

        // Create a list of LBTerrainTexture objects
        // These contain the textures and normal maps but also the rules for applying them to the terrain
        landscape.terrainTexturesList = new List <LBTerrainTexture>();

        // Populate the list by creating temporary LBTerrainTexture objects and adjusting their settings,
        // then adding each one into the list

        // Grass Hill texture
        LBTerrainTexture tempTerrainTexture = new LBTerrainTexture();
        if (tempTerrainTexture != null)
        {
            tempTerrainTexture.texture   = grassHillTexture;
            tempTerrainTexture.normalMap = grassHillNormalMap;

            tempTerrainTexture.tileSize       = Vector2.one * 25f;
            tempTerrainTexture.minInclination = 0f;
            tempTerrainTexture.maxInclination = 45f;
            tempTerrainTexture.useNoise       = true;
            tempTerrainTexture.noiseTileSize  = 100f;
            tempTerrainTexture.texturingMode  = LBTerrainTexture.TexturingMode.Inclination;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Rock Layered texture
            tempTerrainTexture                = new LBTerrainTexture();
            tempTerrainTexture.texture        = rockLayeredTexture;
            tempTerrainTexture.normalMap      = rockLayeredNormalMap;
            tempTerrainTexture.tileSize       = Vector2.one * 100f;
            tempTerrainTexture.minInclination = 30f;
            tempTerrainTexture.maxInclination = 90f;
            tempTerrainTexture.useNoise       = true;
            tempTerrainTexture.noiseTileSize  = 100f;
            tempTerrainTexture.texturingMode  = LBTerrainTexture.TexturingMode.Inclination;
            landscape.terrainTexturesList.Add(tempTerrainTexture);

            // Texture the terrains
            landscape.ApplyTextures(true, true);
        }

        // Add a tree type
        LBTerrainTree tempTerrainTree = new LBTerrainTree();
        if (tempTerrainTree != null && treePrefab != null)
        {
            // Set tree type options as required. See LBTerrainTree class constructor for default settings
            tempTerrainTree.prefab           = treePrefab.gameObject;
            tempTerrainTree.maxTreesPerSqrKm = 100;
            tempTerrainTree.treePlacingMode  = LBTerrainTree.TreePlacingMode.HeightAndInclination;
            tempTerrainTree.minInclination   = 0f;
            tempTerrainTree.maxInclination   = 30f;
            tempTerrainTree.minHeight        = (waterHeight + 2f) / terrainHeight;

            // Create a new filter, which will be used for the Stencil Layer
            // This demonstrates how to apply a stencil layer to the placement of trees
            LBFilter lbFilterTree = LBFilter.CreateFilter(lbStencil, "Hills Layer 1", true);

            if (lbFilterTree != null)
            {
                // If the list of filters isn't defined, create an empty list
                if (tempTerrainTree.filterList == null)
                {
                    tempTerrainTree.filterList = new List <LBFilter>();
                }

                // Add the Stencil Layer to the list of Tree Filters
                tempTerrainTree.filterList.Add(lbFilterTree);
            }

            // Add the tree type configuration to the landscape
            landscape.terrainTreesList.Add(tempTerrainTree);

            // Populate the landscape with the trees
            landscape.ApplyTrees(true, true);
        }

        // Add some rock prefabs to the landscape
        LBLandscapeMesh lbLandscapeMesh = new LBLandscapeMesh();
        if (lbLandscapeMesh != null && rockPrefab != null)
        {
            lbLandscapeMesh.usePrefab = true;
            lbLandscapeMesh.prefab    = rockPrefab;
            // Set mesh options as required. See LBLandscapeMesh class constructor for default settings
            lbLandscapeMesh.maxMeshes = 100;
            // Sink the rocks into the ground by 0.5m
            lbLandscapeMesh.offset = new Vector3(0f, -0.5f, 0f);
            // Place the rocks near the water's edge
            lbLandscapeMesh.meshPlacingMode = LBLandscapeMesh.MeshPlacingMode.HeightAndInclination;
            lbLandscapeMesh.minHeight       = (waterHeight + 1f) / terrainHeight;
            lbLandscapeMesh.maxHeight       = lbLandscapeMesh.minHeight + (10f / terrainHeight);
            lbLandscapeMesh.maxInclination  = 12.5f;
            lbLandscapeMesh.useNoise        = true;
            // Group the rocks together
            lbLandscapeMesh.isClustered     = true;
            lbLandscapeMesh.clusterDensity  = 0.1f;
            lbLandscapeMesh.clusterDistance = 10f;
            //lbLandscapeMesh.minProximity = 10f;

            landscape.landscapeMeshList.Add(lbLandscapeMesh);

            landscape.ApplyMeshes(true, true);
        }

        // Display the total time taken to generate the landscape (usually for debugging purposes)
        Debug.Log("Time taken to generate landscape: " + (Time.realtimeSinceStartup - generationStartTime).ToString("00.00") + " seconds.");
    }