public IEnumerator RefreshTilesLayers()
{
//Clear
terrainLayers.Clear();
//Create Layers
for (int i = 0; i < layers.Count; i++)
{
TerrainLayer terrainLayer = new TerrainLayer();
System.Guid g = System.Guid.NewGuid();
string GuidString = System.Convert.ToBase64String(g.ToByteArray());
GuidString = GuidString.Replace("=", "");
GuidString = GuidString.Replace("+", "");
UnityEditor.AssetDatabase.CreateAsset(terrainLayer, "Assets/MWS/TerrainLayers/terrainLayer" + GuidString + ".terrainlayer");
terrainLayers.Add(terrainLayer);
}
//Apply Layers
TerrainLayer[] terrainLayerArray = terrainLayers.ToArray();
for (int i = 0; i < tiles.Count; i++)
{
tiles[i].terrainData.terrainLayers = terrainLayerArray;
Debug.Log(tiles[i].terrainData.terrainLayers.Length);
}
yield return(null);
}
/// <summary>
/// Executes the modifiers in order and generates the necessary splatmaps
/// </summary>
/// <param name="layer"></param>
/// <param name="modifiers"></param>
/// <param name="output"></param>
public static void Execute(Terrain terrain, TerrainLayer layer, List <Modifier> modifiers)
{
Graphics.ClearRandomWriteTargets();
Graphics.SetRenderTarget(alphaMap);
//Start with a full white base
Graphics.Blit(Texture2D.whiteTexture, alphaMap);
//Reverse order
for (int i = modifiers.Count - 1; i >= 0; i--)
{
modifiers[i].Configure(filterMat);
modifiers[i].Execute(alphaMap);
}
//Scale splatmap to fit in terrain
Vector2 scaledSplatmapSize = new Vector2((terrain.terrainData.size.x / m_resolution) * m_resolution, (terrain.terrainData.size.z / m_resolution) * m_resolution);
//PaintContext handles creation of splatmaps. Subtracting the weights of a splatmap, from the ones before it.
//A single pixels of all combined alpha maps must not exceed a value of one. The 2nd pass of Hidden/TerrainEngine/TerrainLayerUtils is used internally to do this
//Note: Paintcontext must use a serialized terrain reference, otherwise breaks when executing "ApplyDelayedActions" when the project is saved!
PaintContext c = TerrainPaintUtility.BeginPaintTexture(terrain, new Rect(0, 0, scaledSplatmapSize.x, scaledSplatmapSize.y), layer);
Graphics.Blit(alphaMap, c.destinationRenderTexture);
TerrainPaintUtility.EndPaintTexture(c, "Painted terrain");
}
public static TerrainLayer createTerrainLayer(Material mat, float tiling)
{
TerrainLayer terrainLayer = new TerrainLayer();
string path = AssetDatabase.GetAssetPath(mat);
path = path.Replace(".mat", ".terrainlayer");
AssetDatabase.CreateAsset(terrainLayer, path);
AssetDatabase.Refresh();
terrainLayer.diffuseTexture = (Texture2D)mat.mainTexture;
//attempt to auto-detect a settings file for Lightweight or HD pipelines
switch (MegascansUtilities.getCurrentPipeline())
{
case Pipeline.HDRP:
terrainLayer.normalMapTexture = (Texture2D)mat.GetTexture("_NormalMap");
if (mat.GetFloat("_MaterialID") == 4)
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_SpecularColorMap");
terrainLayer.metallic = 1.0f;
}
else if (mat.GetFloat("_MaterialID") == 1)
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_MaskMap");
terrainLayer.specular = new Color(1.0f, 1.0f, 1.0f);
}
break;
case Pipeline.LWRP:
terrainLayer.normalMapTexture = (Texture2D)mat.GetTexture("_BumpMap");
if (mat.GetFloat("_WorkflowMode") == 1)
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_MetallicGlossMap");
terrainLayer.specular = new Color(1.0f, 1.0f, 1.0f);
}
else
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_SpecGlossMap");
terrainLayer.metallic = 1.0f;
}
break;
case Pipeline.Standard:
terrainLayer.normalMapTexture = (Texture2D)mat.GetTexture("_BumpMap");
if (mat.shader.ToString() == "Standard (Specular setup)")
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_SpecGlossMap");
terrainLayer.metallic = 1.0f;
}
else
{
terrainLayer.maskMapTexture = (Texture2D)mat.GetTexture("_MetallicGlossMap");
terrainLayer.specular = new Color(1.0f, 1.0f, 1.0f);
}
break;
}
terrainLayer.tileSize = new Vector2(tiling, tiling);
return(terrainLayer);
}
internal static void ReplaceTerrainLayer(Terrain terrain, int index, TerrainLayer inputLayer)
{
if (inputLayer == null)
{
RemoveTerrainLayer(terrain, index);
return;
}
var layers = terrain.terrainData.terrainLayers;
// Make sure the selection is legit
if (index < 0 || index > layers.Length)
{
return;
}
// See if they're already using this layer
for (var idx = 0; idx < layers.Length; ++idx)
{
if (layers[idx] == inputLayer)
{
return;
}
}
layers[index] = inputLayer;
terrain.terrainData.SetTerrainLayersRegisterUndo(layers, "Replace terrain layer");
}
public override void LoadContent()
{
base.LoadContent();
_grid = BlackBoard.GetEntry <Grid>("Grid");
_terrainLayer = BlackBoard.GetEntry <TerrainLayer>("TerrainLayer");
_counters[0] = _grid.Size;
}
private TerrainLayer createLayer(Biome name, Texture2D texture)
{
var layer = new TerrainLayer();
layer.diffuseTexture = texture;
return(layer);
}
internal static void AddTerrainLayer(Terrain terrain, TerrainLayer inputLayer)
{
if (inputLayer == null)
{
return;
}
var terrainData = terrain.terrainData;
var layers = terrainData.terrainLayers;
for (var idx = 0; idx < layers.Length; ++idx)
{
if (layers[idx] == inputLayer)
{
return;
}
}
int newIndex = layers.Length;
var newarray = new TerrainLayer[newIndex + 1];
Array.Copy(layers, 0, newarray, 0, newIndex);
newarray[newIndex] = inputLayer;
terrainData.SetTerrainLayersRegisterUndo(newarray, "Add terrain layer");
}
// add a list of terrain layers to terrain, and have an option of clear existing ones
public static void AddLayersToTerrain(TerrainData terrainData, List <TerrainLayer> layers, bool clearExisting)
{
if (terrainData == null || layers == null)
{
return;
}
Undo.RegisterCompleteObjectUndo(terrainData, "Add terrain layer");
if (clearExisting)
{
terrainData.terrainLayers = layers.ToArray();
}
else
{
// check and remove existing layers
var filteredLayers = layers.Where(l => !terrainData.terrainLayers.Contains(l)).ToArray();
int oldLength = terrainData.terrainLayers.Length;
int newLength = oldLength + filteredLayers.Length;
var newArray = new TerrainLayer[newLength];
terrainData.terrainLayers.CopyTo(newArray, 0);
filteredLayers.CopyTo(newArray, oldLength);
terrainData.terrainLayers = newArray;
}
}
// add layer to terrain
public static void AddLayerToTerrain(TerrainData terrainData, TerrainLayer inputLayer)
{
if (inputLayer == null)
{
return;
}
Undo.RegisterCompleteObjectUndo(terrainData, "Add terrain layer");
var layers = terrainData.terrainLayers;
for (var idx = 0; idx < layers.Length; ++idx)
{
if (layers[idx] == inputLayer)
{
return;
}
}
int newIndex = layers.Length;
var newarray = new TerrainLayer[newIndex + 1];
Array.Copy(layers, 0, newarray, 0, newIndex);
newarray[newIndex] = inputLayer;
terrainData.terrainLayers = newarray;
}
public static TerrainTextureData[] GetTerrainTextureDatas(TerrainData data)
{
#if UNITY_2018_3_OR_NEWER
var arr = new TerrainTextureData[data.terrainLayers.Length];
for (var i = 0; i < data.terrainLayers.Length; i++)
{
TerrainLayer layer = data.terrainLayers[i];
arr[i] = new TerrainTextureData
(
layer.normalMapTexture,
layer.maskMapTexture,
layer.diffuseTexture
);
}
return(arr);
#else
var arr = new TerrainTextureData[data.splatPrototypes.Length];
for (int i = 0; i < data.splatPrototypes.Length; i++)
{
var layer = data.splatPrototypes[i];
arr[i] = new TerrainTextureData
(
layer.normalMap,
layer.texture
);
}
return(arr);
#endif
}
private void drawTerrainLayerMaterial(int index)
{
EditorGUILayout.BeginHorizontal();
TerrainLayer layer = terrainLayers[index];
if (layer != null)
{
GUILayout.Box(layer.diffuseTexture, GUILayout.Height(40), GUILayout.Width(40));
}
else
{
GUILayout.Box(new GUIContent(), GUILayout.Height(40), GUILayout.Width(40));
}
EditorGUILayout.BeginVertical();
if (layer != null)
{
EditorGUILayout.LabelField(layer.diffuseTexture.name);
}
else
{
EditorGUILayout.LabelField("Missing Terrain Layer");
}
terrain.TerrainMaterials[index] = EditorGUILayout.ObjectField("", terrain.TerrainMaterials[index], typeof(ImpactMaterialBase), false) as ImpactMaterialBase;
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
}
public override void ApplicationDidFinishLaunching(CCApplication application, CCWindow mainWindow)
{
application.ContentRootDirectory = "Content";
var screen = new ScreenDetails(application, mainWindow);
var logger = new ConsoleLogger(GridGame.Library.Enums.LogLevel.debug);
GameData gameData = new GameData(logger)
{
Screen = screen,
Input = new EnvironmentInputs(),
Player = new PlayerPosition(),
};
screen.SetDefaultDesignResolution();
var scene = new CCScene(mainWindow);
var introLayer = new TerrainLayer(gameData);
var playerLayer = new PlayerLayer(gameData);
scene.AddChild(introLayer);
scene.AddChild(playerLayer);
mainWindow.RunWithScene(scene);
}
void OnValidate()
{
if (Width < 1)
{
Width = 1;
}
if (Height < 1)
{
Height = 1;
}
if (Lacunarity < 1)
{
Lacunarity = 1;
}
if (Layers.Length == 0)
{
Layers = new TerrainLayer[2];
Layers[0] = new TerrainLayer()
{
Color = Color.blue, Height = 0.4f, Name = "Water"
};
Layers[1] = new TerrainLayer()
{
Color = Color.green, Height = 1.0f, Name = "Land"
};
}
}
/// <summary>
/// Applies an array of Gaia Splat prototypes to a terrain. Uses the correct terrain API for pre and post Unity 2018.3.
/// </summary>
/// <param name="terrain">The terrain to assign the splat prototypes to.</param>
/// <param name="splats">Array of GaiaSplatPrototypes to assign to the terrain.</param>
/// <param name="terrainName">The current Gaia profile. Used for terrain layer asset filenames.</param>
public static void SetGaiaSplatPrototypes(Terrain terrain, GaiaSplatPrototype[] splats, string terrainName)
{
if (terrain != null && splats != null)
{
#if UNITY_2018_3_OR_NEWER
TerrainLayer[] terrainLayers = new TerrainLayer[splats.Length];
for (int i = 0; i < splats.Length; i++)
{
terrainLayers[i] = splats[i].Convert();
}
//completely remove all old splat prototypes first to prevent build-up of abandoned files
RemoveTerrainLayerAssetFiles(terrainName);
//Permanently save the new layers as asset files & get a reference, else they will not work properly in the terrain
for (int i = 0; i < terrainLayers.Length; i++)
{
terrainLayers[i] = SaveTerrainLayerAsAsset(terrainName, i.ToString(), terrainLayers[i]);
}
terrain.terrainData.terrainLayers = terrainLayers;
#else
SplatPrototype[] splatPrototypes = new SplatPrototype[splats.Length];
for (int i = 0; i < splats.Length; i++)
{
splatPrototypes[i] = splats[i].Convert();
}
terrain.terrainData.splatPrototypes = splatPrototypes;
#endif
}
}
public override bool OnPaint(Terrain terrain, IOnPaint editContext)
{
BrushTransform targetBrushXform = TerrainPaintUtility.CalculateBrushTransform(terrain, editContext.uv, editContext.brushSize, 1);
Material mat = GetPaintMaterial();
Vector4 brushParams = new Vector4(editContext.brushStrength, 0, 0, 0f);
mat.SetTexture("_BrushTex", editContext.brushTexture);
mat.SetVector("_BrushParams", brushParams);
Rect targetRect = targetBrushXform.GetBrushXYBounds();
int numSampleTerrainLayers = terrain.terrainData.terrainLayers.Length;
for (int i = 0; i < numSampleTerrainLayers; ++i)
{
TerrainLayer layer = terrain.terrainData.terrainLayers[i];
if (layer == null)
{
continue;
}
int layerIndex = TerrainPaintUtility.FindTerrainLayerIndex(terrain, layer);
Texture2D layerTexture = TerrainPaintUtility.GetTerrainAlphaMapChecked(terrain, layerIndex >> 2);
PaintContext targetContext = PaintContext.CreateFromBounds(terrain, targetRect, layerTexture.width, layerTexture.height);
targetContext.CreateRenderTargets(RenderTextureFormat.R8);
targetContext.GatherAlphamap(layer, true);
Graphics.Blit(targetContext.sourceRenderTexture, targetContext.destinationRenderTexture, mat, 0);
TerrainPaintUtility.EndPaintTexture(targetContext, "Terrain Paint - Smooth Splatmaps");
}
return(false);
}
public void TerrainToolboxUtilites_WhenApplySplatmaps_DoesNotDividebyZero()
{
// Preparation:
// Collect data, create needed objects
Texture2D texture = new Texture2D(512, 512);
TerrainLayer layer = new TerrainLayer();
layer.diffuseTexture = texture;
TerrainLayer[] terrainLayers = { layer };
//Add splatmap to terrain in order to import into the Utilities Window
m_TerrainComponent.terrainData.terrainLayers = terrainLayers;
Selection.activeGameObject = m_TerrainGO;
// Execute the repro steps in code
TerrainToolboxWindow toolboxWindow = EditorWindow.GetWindow(typeof(TerrainToolboxWindow)) as TerrainToolboxWindow;
toolboxWindow.m_TerrainUtilitiesMode.ImportSplatmapsFromTerrain(true);
Selection.activeGameObject = null;
Assert.That(() =>
{
toolboxWindow.m_TerrainUtilitiesMode.ExportSplatmapsToTerrain(true);
}, !Throws.TypeOf <System.DivideByZeroException>());
toolboxWindow.Close();
}
public IEnumerator Test_PaintTexture_Playback(string recordingFilePath, string targetTerrainName)
{
yield return(null);
Terrain t = GameObject.Find("Terrain").GetComponent <Terrain>();
InitTerrainTypesWithReflection("PaintTextureTool");
onPaintHistory = LoadDataFile(recordingFilePath);
SetupTerrain(targetTerrainName);
TerrainLayer tl1 = new TerrainLayer(), tl2 = new TerrainLayer();
tl1.diffuseTexture = Resources.Load <Texture2D>("testGradientCircle");
tl2.diffuseTexture = Resources.Load <Texture2D>("testGradientCircle");
terrainObj.terrainData.terrainLayers = new TerrainLayer[] { tl1, tl2 };
PaintTextureTool paintTextureTool = terrainToolInstance as PaintTextureTool;
FieldInfo selectedTerrainLayerInfo = typeof(PaintTextureTool).GetField("m_SelectedTerrainLayer",
s_bindingFlags);
selectedTerrainLayerInfo.SetValue(paintTextureTool, tl2);
// Enables the core brush playback on OnSceneGUI
SceneView.duringSceneGui -= OnSceneGUI;
SceneView.duringSceneGui += OnSceneGUI;
while (onPaintHistory.Count > 0)
{
// Force a SceneView update for OnSceneGUI to be triggered
SceneView.RepaintAll();
yield return(null);
}
Assert.Pass("Matrix stack regression not found!");
}
/*
* Generate a Texture2D to apply on the terrain layer.
* <param name="noiseMap">Noise map that will be used to get data of the terrain</param>
* <param name="terrainTypes">Data to compare against the noise map</param>
* <param name="chosenTerrainTypes">Infomation of each vertice in the terrain</param>
*/
private TerrainLayer BuildTexture(float[,] noiseMap, TerrainType[] terrainTypes, TerrainType[,] chosenTerrainTypes)
{
var terrainLayer = new TerrainLayer();
int tileDepth = noiseMap.GetLength(0);
int tileWidth = noiseMap.GetLength(1);
terrainLayer.tileSize = new Vector2(tileDepth, tileWidth);
var colorMap = new Color[tileDepth * tileWidth];
for (int zIndex = 0; zIndex < tileDepth; zIndex++)
{
for (int xIndex = 0; xIndex < tileWidth; xIndex++)
{
int colorIndex = zIndex * tileWidth + xIndex;
float noise = noiseMap[zIndex, xIndex];
var terrainType = ChooseTerrainType(noise, terrainTypes);
colorMap[colorIndex] = terrainType.color;
chosenTerrainTypes[zIndex, xIndex] = terrainType;
}
}
var tileTexture = new Texture2D(tileWidth, tileDepth);
tileTexture.wrapMode = TextureWrapMode.Clamp;
tileTexture.SetPixels(colorMap);
tileTexture.Apply();
terrainLayer.diffuseTexture = tileTexture;
return(terrainLayer);
}
private void EndRecordLayerProperties()
{
IRTE editor = IOC.Resolve <IRTE>();
Terrain terrain = Terrain;
int layerIndex = m_layersList.SelectedIndex;
Vector2 tileSize = SelectedLayer.tileSize;
Vector2 tileOffset = SelectedLayer.tileOffset;
editor.Undo.CreateRecord(record =>
{
TerrainLayer layer = terrain.terrainData.terrainLayers[layerIndex];
if (layer != null)
{
layer.tileOffset = tileOffset;
layer.tileSize = tileSize;
}
return(true);
},
record =>
{
TerrainLayer layer = terrain.terrainData.terrainLayers[layerIndex];
if (layer != null)
{
layer.tileOffset = m_initialTileOffset;
layer.tileSize = m_initialTileSize;
}
return(true);
});
}
private void SetNormals()
{
#if UNITY_2017 || UNITY_2018_1 || UNITY_2018_2
var splatProtos = new List <SplatPrototype>();
for (var i = 0; i < albedos.Count; i++)
{
var prototype = new SplatPrototype();
prototype.texture = albedos[i];
prototype.normalMap = normals[normalCount[i]];
splatProtos.Insert(i, prototype);
}
Undo.RegisterCompleteObjectUndo(terrain.gameObject, "AddNormalsToSplats");
terrain.terrainData.splatPrototypes = splatProtos.ToArray();
#endif
#if UNITY_2018_3_OR_NEWER
var splatProtos = new List <TerrainLayer>();
for (var i = 0; i < albedos.Count; i++)
{
var prototype = new TerrainLayer();
prototype.diffuseTexture = albedos[i];
prototype.normalMapTexture = normals[normalCount[i]];
splatProtos.Insert(i, prototype);
}
Undo.RegisterCompleteObjectUndo(terrain.gameObject, "AddNormalsToSplats");
terrain.terrainData.terrainLayers = splatProtos.ToArray();
#endif
terrain.Flush();
terrain.terrainData.RefreshPrototypes();
Close();
}
public static bool ImportTerrainAll(TerrainLayer m)
{
using var ofd = new OpenFileDialog
{
Filter = "New Horizons Terrain (*.nht)|*.nht|All files (*.*)|*.*",
FileName = "terrainAcres.nht",
};
if (ofd.ShowDialog() != DialogResult.OK)
{
return(false);
}
var path = ofd.FileName;
var fi = new FileInfo(path);
int expect = m.MaxTileCount * TerrainTile.SIZE;
if (fi.Length != expect)
{
WinFormsUtil.Error(string.Format(MessageStrings.MsgDataSizeMismatchImport, fi.Length, expect));
return(false);
}
var data = File.ReadAllBytes(path);
m.ImportAll(data);
return(true);
}
public sealed override Texture2D RenderStaticPreview(string assetPath, UnityEngine.Object[] subAssets, int width, int height)
{
TerrainLayer t = AssetDatabase.LoadMainAssetAtPath(assetPath) as TerrainLayer;
if (t == null || t.diffuseTexture == null)
{
return(null);
}
int texwidth = t.diffuseTexture.width;
int texheight = t.diffuseTexture.height;
PreviewHelpers.AdjustWidthAndHeightForStaticPreview(texwidth, texheight, ref width, ref height);
RenderTexture oldRT = RenderTexture.active;
RenderTexture tempRT = RenderTexture.GetTemporary(width, height, 0, RenderTextureFormat.ARGB32);
Graphics.Blit(t.diffuseTexture, tempRT);
Texture2D previewTexture = new Texture2D(width, height, TextureFormat.ARGB32, false);
RenderTexture.active = tempRT;
previewTexture.ReadPixels(new Rect(0, 0, width, height), 0, 0);
previewTexture.Apply();
RenderTexture.ReleaseTemporary(tempRT);
tempRT = null;
RenderTexture.active = oldRT;
return(previewTexture);
}
public void GatherAlphamap(TerrainLayer inputLayer, bool addLayerIfDoesntExist = true)
{
if (inputLayer == null)
{
return;
}
Material copyTerrainLayerMaterial = TerrainPaintUtility.GetCopyTerrainLayerMaterial();
Vector4[] layerMasks = { new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1) };
GatherInternal(
t =>
{ // return the texture to be gathered from this terrain tile
SplatmapUserData userData = GetTerrainLayerUserData(t, inputLayer, addLayerIfDoesntExist);
if (userData != null)
{
return(TerrainPaintUtility.GetTerrainAlphaMapChecked(t.terrain, userData.mapIndex));
}
else
{
return(null);
}
},
new Color(0.0f, 0.0f, 0.0f, 0.0f),
"PaintContext.GatherAlphamap",
copyTerrainLayerMaterial, 0,
t =>
{ // before blit -- setup layer mask in the material
SplatmapUserData userData = GetTerrainLayerUserData(t);
copyTerrainLayerMaterial.SetVector("_LayerMask", layerMasks[userData.channelIndex]);
});
}
void OnSelectLayerElement(ReorderableList list)
{
if (m_SelectedTerrain.terrainData.terrainLayers.Length > list.index)
{
m_SelectedTerrainLayer = m_SelectedTerrain.terrainData.terrainLayers[list.index];
}
}
public override void Build(World world, Chunk chunk, Vector3Int pos, TerrainLayer layer)
{
int noise = layer.GetNoise(pos.x, pos.y, pos.z, 1f, 3, 1);
int leavesRange = noise + 3;
int leavesRange2 = leavesRange * leavesRange;
int trunkHeight = posY - noise;
float a2inv = 1.0f / leavesRange2;
float b2inv = 1.0f / ((leavesRange - 1) * (leavesRange - 1));
for (int y = -leavesRange + 1; y <= leavesRange - 1; y++)
{
for (int z = -leavesRange; z <= leavesRange; z++)
{
for (int x = -leavesRange; x <= leavesRange; x++)
{
if (x * x * a2inv + z * z * a2inv + y * y * b2inv <= 1.0f) // An ellipsoid flattened on the y axis
{
blocks.Set(pos.Add(x, y + trunkHeight, z), leaves);
}
}
}
}
blocks.Set(pos, log);
for (int y = 1; y <= trunkHeight; y++)
{
blocks.Set(pos.Add(0, y, 0), log);
}
}
private void PaintAlphamap(Terrain sampleTerrain, Terrain targetTerrain, BrushTransform sampleXform, BrushTransform targetXform, Material mat)
{
Rect sampleRect = sampleXform.GetBrushXYBounds();
Rect targetRect = targetXform.GetBrushXYBounds();
int numSampleTerrainLayers = sampleTerrain.terrainData.terrainLayers.Length;
for (int i = 0; i < numSampleTerrainLayers; ++i)
{
TerrainLayer layer = sampleTerrain.terrainData.terrainLayers[i];
if (layer == null)
{
continue; // nothing to paint if the layer is NULL
}
PaintContext sampleContext = TerrainPaintUtility.BeginPaintTexture(sampleTerrain, sampleRect, layer);
// manually create target context since we are possibly applying another terrain's layers and not its own
int layerIndex = TerrainPaintUtility.FindTerrainLayerIndex(sampleTerrain, layer);
Texture2D layerTexture = TerrainPaintUtility.GetTerrainAlphaMapChecked(sampleTerrain, layerIndex >> 2);
PaintContext targetContext = PaintContext.CreateFromBounds(targetTerrain, targetRect, layerTexture.width, layerTexture.height);
targetContext.CreateRenderTargets(RenderTextureFormat.R8);
targetContext.GatherAlphamap(layer, true);
sampleContext.sourceRenderTexture.filterMode = FilterMode.Point;
mat.SetTexture("_CloneTex", sampleContext.sourceRenderTexture);
Graphics.Blit(targetContext.sourceRenderTexture, targetContext.destinationRenderTexture, mat, (int)ShaderPasses.CloneAlphamap);
// apply texture modifications and perform cleanup. same thing as calling TerrainPaintUtility.EndPaintTexture
targetContext.ScatterAlphamap("Terrain Paint - Clone Brush (Texture)");
targetContext.Cleanup();
}
}
public static Bitmap CreateMap(TerrainLayer mgr, int scale, int x, int y, int[] scale1, int[] scaleX, Bitmap map)
{
CreateMap(mgr, scale1);
ImageUtil.ScalePixelImage(scale1, scaleX, map.Width, map.Height, scale);
ImageUtil.SetBitmapData(map, scaleX);
return(DrawReticle(map, mgr, x, y, scale));
}
private void GenerateGenericJSON() //For testing purposes
{
TerrainLayer[] arr = new TerrainLayer[2];
TerrainLayer terrainLayer1 = new TerrainLayer("Water", 0.0f, 0.3f, Color.blue);
TerrainLayer terrainLayer2 = new TerrainLayer("Sand", 0.3f, 0.4f, Color.yellow);
TerrainLayer terrainLayer3 = new TerrainLayer("Grass", 0.4f, 1.0f, Color.green, false);
string json1 = JsonUtility.ToJson(terrainLayer1);
string json2 = JsonUtility.ToJson(terrainLayer2);
string json3 = JsonUtility.ToJson(terrainLayer3);
List <string> jsonList = new List <string>
{
json1,
json2,
json3
};
Debug.Log("first json: " + json1);
try
{
File.WriteAllLines(PrefPath + "DefaultTerrainLayers.json", jsonList);
} catch
{
}
}
public override void OnInspectorGUI(Terrain terrain, IOnInspectorGUI editContext)
{
GUILayout.Label("Settings", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
EditorGUILayout.Space();
Editor.DrawFoldoutInspector(terrain.materialTemplate, ref m_TemplateMaterialEditor);
EditorGUILayout.Space();
if (m_SelectedTerrainLayerIndex == -1)
{
m_SelectedTerrainLayerIndex = TerrainPaintUtility.FindTerrainLayerIndex(terrain, m_SelectedTerrainLayer);
}
m_SelectedTerrainLayerIndex = TerrainLayerUtility.ShowTerrainLayersSelectionHelper(terrain, m_SelectedTerrainLayerIndex);
EditorGUILayout.Space();
if (EditorGUI.EndChangeCheck())
{
m_SelectedTerrainLayer = m_SelectedTerrainLayerIndex != -1 ? terrain.terrainData.terrainLayers[m_SelectedTerrainLayerIndex] : null;
Save(true);
}
terrain.materialTemplate.SetFloat("_NumLayersCount", terrain.terrainData.terrainLayers.Length);
TerrainLayerUtility.ShowTerrainLayerGUI(terrain, m_SelectedTerrainLayer, ref m_SelectedTerrainLayerInspector,
(m_TemplateMaterialEditor as MaterialEditor)?.customShaderGUI as ITerrainLayerCustomUI);
EditorGUILayout.Space();
int textureRez = terrain.terrainData.alphamapResolution;
editContext.ShowBrushesGUI(5, BrushGUIEditFlags.All, textureRez);
}
public override void OnInspectorGUI(Terrain terrain, IOnInspectorGUI editContext)
{
GUILayout.Label("Settings", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
EditorGUILayout.Space();
Editor.DrawFoldoutInspector(terrain.materialTemplate, ref m_TemplateMaterialEditor);
EditorGUILayout.Space();
int layerIndex = TerrainPaintUtility.FindTerrainLayerIndex(terrain, m_SelectedTerrainLayer);
layerIndex = TerrainLayerUtility.ShowTerrainLayersSelectionHelper(terrain, layerIndex);
EditorGUILayout.Space();
if (EditorGUI.EndChangeCheck())
{
m_SelectedTerrainLayer = layerIndex != -1 ? terrain.terrainData.terrainLayers[layerIndex] : null;
Save(true);
}
TerrainLayerUtility.ShowTerrainLayerGUI(terrain, m_SelectedTerrainLayer, ref m_SelectedTerrainLayerInspector,
(m_TemplateMaterialEditor as MaterialEditor)?.customShaderGUI as ITerrainLayerCustomUI);
EditorGUILayout.Space();
editContext.ShowBrushesGUI(5);
}
public override void Build(World world, BlockPos chunkPos, BlockPos pos, TerrainLayer layer)
{
int leaves = layer.GetNoise(pos.x, 0, pos.z, 1f, 2, 1) +1;
for (int x = -leaves; x <= leaves; x++)
{
for (int y = 3; y <= 6; y++)
{
for (int z = -leaves; z <= leaves; z++)
{
if (Chunk.InRange(pos.x + x - chunkPos.x) && Chunk.InRange(pos.z + z - chunkPos.z))
{
Block block = "leaves";
block.modified = false;
world.SetBlock(pos.Add(x, y, z), block, false);
}
}
}
}
for (int y = 0; y <= 5; y++)
{
if (y < Config.Env.WorldMaxY)
{
Block block = "log";
block.modified = false;
world.SetBlock(pos.Add(0, y, 0), block, false);
}
}
}
/// <summary>
/// Invalidates the specified terrain layer in the data cached by the renderer.
/// </summary>
/// <param name="tile">The terrain tile owning the terrain layer.</param>
/// <param name="layer">The terrain layer which should be invalidated.</param>
/// <inheritdoc cref="Invalidate()"/>
/// <exception cref="ArgumentNullException">
/// <paramref name="tile"/> or <paramref name="layer"/> is <see langword="null"/>.
/// </exception>
public void Invalidate(TerrainTile tile, TerrainLayer layer)
{
if (tile == null)
throw new ArgumentNullException("tile");
if (layer == null)
throw new ArgumentNullException("layer");
UpdateAabb();
Aabb aabb = layer.Aabb ?? tile.Aabb;
if (layer.Material.Contains(TerrainClipmapRenderer.RenderPassBase)
&& !RegionsContain(InvalidBaseRegions, aabb))
{
InvalidBaseRegions.Add(aabb);
// If there are 2 or more AABBs, then they need clipping.
AreInvalidBaseRegionsClipped = (InvalidBaseRegions.Count == 1);
}
if (layer.Material.Contains(TerrainClipmapRenderer.RenderPassDetail)
&& !RegionsContain(InvalidDetailRegions, aabb))
{
InvalidDetailRegions.Add(aabb);
// If there are 2 or more AABBs, then they need clipping.
AreInvalidDetailRegionsClipped = (InvalidDetailRegions.Count == 1);
}
}
void AddToLayerOrder(TerrainLayer layer)
{
List<TerrainLayer> layers = new List<TerrainLayer>();
layers.AddRange(gen.layerOrder);
layers.Add(layer);
gen.layerOrder = layers.ToArray();
EditorUtility.SetDirty(gen);
}
public virtual void Build(World world, BlockPos chunkPos, BlockPos pos, TerrainLayer layer) { }
/// <summary>
/// Invalidates the specified terrain layer in the data cached by the renderer.
/// </summary>
/// <param name="layer">The terrain layer which should be invalidated.</param>
/// <inheritdoc cref="Graphics.Terrain.Invalidate()"/>
/// <exception cref="ArgumentNullException">
/// <paramref name="layer"/> is <see langword="null"/>.
/// </exception>
public void Invalidate(TerrainLayer layer)
{
if (Terrain != null)
Terrain.Invalidate(this, layer);
}
/// <summary>
/// Invalidates the specified terrain layer in the data cached by the renderer.
/// </summary>
/// <param name="layer">The terrain layer which should be invalidated.</param>
/// <inheritdoc cref="Invalidate()"/>
/// <exception cref="ArgumentNullException">
/// <paramref name="layer"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="GraphicsException">
/// <paramref name="layer"/> does not have a valid AABB. This method cannot be used. Use one of
/// the other method overloads instead.
/// </exception>
public void Invalidate(TerrainLayer layer)
{
if (layer == null)
throw new ArgumentNullException("layer");
if (!layer.Aabb.HasValue)
throw new GraphicsException("The specified terrain layer does not have a valid AABB.");
Aabb aabb = layer.Aabb.Value;
if (layer.Material.Contains(TerrainClipmapRenderer.RenderPassBase)
&& !RegionsContain(InvalidBaseRegions, aabb))
{
InvalidBaseRegions.Add(aabb);
// If there are 2 or more AABBs, then they need clipping.
AreInvalidBaseRegionsClipped = (InvalidBaseRegions.Count == 1);
}
if (layer.Material.Contains(TerrainClipmapRenderer.RenderPassDetail)
&& !RegionsContain(InvalidDetailRegions, aabb))
{
InvalidDetailRegions.Add(aabb);
// If there are 2 or more AABBs, then they need clipping.
AreInvalidDetailRegionsClipped = (InvalidDetailRegions.Count == 1);
}
}
