Working with Landscape Terrain via Code

using System;
using System.Collections;
using System.Collections.Generic;
using Unigine;
#if UNIGINE_DOUBLE
using Vec3 = Unigine.dvec3;
using Vec2 = Unigine.dvec2;
#else
	using Vec3 = Unigine.vec3;
	using Vec2 = Unigine.vec2;
#endif
[Component(PropertyGuid = "your_component_guid")] // <-here should be a GUID of your component's property
public class LandscapeGenerator : Component
{
	[ShowInEditor]
	private Vec3 lmapPosition = Vec3.ZERO;

	[ShowInEditor]
	private float lmapRotation = 0.0f;

	[ShowInEditor]
	public Vec2 lmapSize = new Vec2(20.0f, 20.0f);

	[ShowInEditor]
	[ParameterSlider(Min = 0.0f)]
	private float lmapHeightScale = 1.0f;

	[ShowInEditor]
	[ParameterSlider(Min = 1)]
	private int lmapGridSizeX = 2;

	[ShowInEditor]
	[ParameterSlider(Min = 1)]
	private int lmapGridSizeY = 2;

	[ShowInEditor]
	[ParameterSlider(Min = 1)]
	private int lmapTileResolutionX = 512;

	[ShowInEditor]
	[ParameterSlider(Min = 1)]
	private int lmapTileResolutionY = 512;

	[ShowInEditor]
	private string lmapName = "map";

	public struct TileImages
	{
		[ParameterFile]
		public string albedoImagePath;

		[ParameterFile]
		public string heightImagePath;
	}

	[ShowInEditor]
	private List<TileImages> tiles = null;

	private ObjectLandscapeTerrain terrain = null;
	private LandscapeLayerMap lmap = null;

	private void Init()
	{
		Unigine.Console.Run("show_messages 1");
		if (tiles == null)
		{
			Log.Error("Fill the array with tiles.\n");
			return;
		}

		if (tiles.Count != lmapGridSizeX * lmapGridSizeY)
		{
			Log.Error("The count of tiles does not match the current grid size.\n");
			return;
		}

		if (string.IsNullOrEmpty(lmapName))
			lmapName = "map";

		// create .lmap file based on tiles with albedo and height images
		var lmapCreator = new LandscapeMapFileCreator();
		lmapCreator.Grid = new ivec2(lmapGridSizeX, lmapGridSizeY);
		lmapCreator.Resolution = new ivec2(lmapTileResolutionX * lmapGridSizeX, lmapTileResolutionY * lmapGridSizeY);
		lmapCreator.Path = lmapName + ".lmap";

		// add callbacks for different stages of creation
		lmapCreator.AddCreateCallback(OnCreatorCreate);
		lmapCreator.AddBeginCallback(OnCreatorBegin);
		lmapCreator.AddProgressCallback(OnCreatorProgress);
		lmapCreator.AddEndCallback(OnCreatorEnd);

		// start the creation process
		lmapCreator.Run();
	}

	private void OnCreatorCreate(LandscapeMapFileCreator creator, LandscapeImages images, int x, int y)
	{
		// get number of the current tile
		int tileNumber = x * lmapGridSizeY + y;
		Log.Message($"Create tile {tileNumber}\n");

		// set albedo for current tile
		if (FileSystem.IsFileExist(tiles[tileNumber].albedoImagePath))
		{
			Image albedoImage = new Image(tiles[tileNumber].albedoImagePath);
			if (albedoImage && albedoImage.Width == lmapTileResolutionX && albedoImage.Height == lmapTileResolutionY)
			{
				Image albedo = images.GetAlbedo();
				albedo.Create2D(albedoImage.Width, albedoImage.Height, albedoImage.Format, albedoImage.NumMipmaps);
				albedo.Copy(albedoImage, 0, 0, 0, 0, albedoImage.Width, albedo.Height);
			}
			else
				Log.Error("The albedo image cannot be loaded, or its resolution does not match the resolution of tile.\n");
		}
		else
			Log.Error("Albedo file does not exist.\n");

		// set height for current tile
		if (FileSystem.IsFileExist(tiles[tileNumber].heightImagePath))
		{
			Image heightImage = new Image(tiles[tileNumber].heightImagePath);
			if (heightImage && heightImage.Width == lmapTileResolutionX && heightImage.Height == lmapTileResolutionY)
			{
				Image height = images.GetHeight();
				height.Create2D(heightImage.Width, heightImage.Height, heightImage.Format, heightImage.NumMipmaps);
				height.Copy(heightImage, 0, 0, 0, 0, heightImage.Width, height.Height);
			}
			else
				Log.Error("The height image cannot be loaded, or its resolution does not match the resolution of tile.\n");
		}
		else
			Log.Error("Height file does not exist.\n");
	}

	private void OnCreatorBegin(LandscapeMapFileCreator creator)
	{
		Log.Message("--------------------\n");
		Log.Message($"--- {creator.Path} creation started ---\n");
		Log.Message("lmap creator begin\n");
	}

	private void OnCreatorProgress(LandscapeMapFileCreator creator)
	{
		Log.Message($"lmap creator progress: {creator.Progress}\n");
	}

	private void OnCreatorEnd(LandscapeMapFileCreator creator)
	{
		Log.Message("lmap creator end\n");
		Log.Message($"--- {creator.Path} created ---\n");
		Log.Message("--------------------\n");

		// after creating .lmap file apply settings
		ApplySettings();

		// and create terrain
		CreateTerrain();
	}

	private void ApplySettings()
	{
		// load target .lmap file for settings
		LandscapeMapFileSettings settings = new LandscapeMapFileSettings();
		settings.Load(FileSystem.GetGUID(lmapName + ".lmap"));

		// set parameters and apply them
		if (settings.IsLoaded)
		{
			// set alpha blend for height and albedo
			settings.HeightBlending = 0;
			settings.AlbedoBlending = 0;

			settings.EnabledHeight = true;
			settings.EnabledAlbedo = true;

			// disable opacity for height and albedo
			settings.EnabledOpacityAlbedo = false;
			settings.EnabledOpacityHeight = false;

			settings.Apply();
		}
	}

	private void CreateTerrain()
	{
		// create new terrain
		terrain = new ObjectLandscapeTerrain();
		terrain.ActiveTerrain = true;
		terrain.SetCollision(true, 0);

		// create layer map based on created .lmap file
		lmap = new LandscapeLayerMap();
		lmap.Parent = Landscape.GetActiveTerrain();
		lmap.Path = lmapName + ".lmap";
		lmap.Name = lmapName;
		lmap.Size = lmapSize;
		lmap.HeightScale = lmapHeightScale;
		lmap.WorldPosition = lmapPosition;
		lmap.SetWorldRotation(new quat(vec3.UP, lmapRotation));
	}

}