| public SetDetailLayer ( int xBase, int yBase, int layer, int details ) : void | ||
| xBase | int | |
| yBase | int | |
| layer | int | |
| details | int | |
| return | void | |
/// <summary>
/// This method allows to load the terrain data (details, heightmaps).
/// </summary>
public void LoadTerrainData()
{
if (!IsInitialized)
{
return;
}
if (ActiveTerrain == null)
{
return;
}
for (int Layer = 0; Layer < Data.detailPrototypes.Length; Layer++)
{
Data.SetDetailLayer(0, 0, Layer, TerrainDetails[Layer]);
}
Data.SetHeights(0, 0, TerrainHeights);
}
private static void ResizeDetailResolution(TerrainData terrainData, int resolution, int resolutionPerPatch)
{
if (resolution == terrainData.detailResolution)
{
List<int[,]> list = new List<int[,]>();
for (int i = 0; i < terrainData.detailPrototypes.Length; i++)
{
list.Add(terrainData.GetDetailLayer(0, 0, terrainData.detailWidth, terrainData.detailHeight, i));
}
terrainData.SetDetailResolution(resolution, resolutionPerPatch);
for (int j = 0; j < list.Count; j++)
{
terrainData.SetDetailLayer(0, 0, j, list[j]);
}
}
else
{
terrainData.SetDetailResolution(resolution, resolutionPerPatch);
}
}
/// <summary>
/// Clone TerrainData object
/// </summary>
/// <param name="source">
/// A <see cref="TerrainData"/>
/// </param>
/// <param name="detailResolutionPerPatch">
/// A <see cref="System.Int32"/>
/// </param>
/// <returns>
/// A <see cref="TerrainData"/>
/// </returns>
public static TerrainData Clone(TerrainData source, int detailResolutionPerPatch)
{
TerrainData dest = new TerrainData();
dest.alphamapResolution = source.alphamapResolution;
dest.baseMapResolution = source.baseMapResolution;
dest.SetDetailResolution(source.detailResolution, detailResolutionPerPatch);
DetailPrototype[] dp = new DetailPrototype[source.detailPrototypes.Length];
for (int i=0; i<dp.Length; i++) dp[i] = new DetailPrototype();
dest.detailPrototypes = dp;
for (int i=0; i<dp.Length; i++)
{
dest.detailPrototypes[i].bendFactor = source.detailPrototypes[i].bendFactor;
dest.detailPrototypes[i].dryColor = source.detailPrototypes[i].dryColor;
dest.detailPrototypes[i].healthyColor = source.detailPrototypes[i].healthyColor;
dest.detailPrototypes[i].maxHeight = source.detailPrototypes[i].maxHeight;
dest.detailPrototypes[i].maxWidth = source.detailPrototypes[i].maxWidth;
dest.detailPrototypes[i].minHeight = source.detailPrototypes[i].minHeight;
dest.detailPrototypes[i].minWidth = source.detailPrototypes[i].minWidth;
dest.detailPrototypes[i].noiseSpread = source.detailPrototypes[i].noiseSpread;
dest.detailPrototypes[i].prototype = source.detailPrototypes[i].prototype;
dest.detailPrototypes[i].prototypeTexture = source.detailPrototypes[i].prototypeTexture;
dest.detailPrototypes[i].renderMode = source.detailPrototypes[i].renderMode;
dest.detailPrototypes[i].usePrototypeMesh = source.detailPrototypes[i].usePrototypeMesh;
dest.SetDetailLayer(0,0,i,source.GetDetailLayer(0,0,source.detailWidth,source.detailHeight,i));
}
dest.RefreshPrototypes();
dest.heightmapResolution = source.heightmapResolution;
dest.SetHeights(0,0,source.GetHeights(0,0,source.heightmapWidth,source.heightmapHeight));
dest.hideFlags = source.hideFlags;
dest.name = source.name+" (Clone)";
dest.size = source.size;
dest.splatPrototypes = source.splatPrototypes;
dest.treeInstances = source.treeInstances;
dest.treePrototypes = source.treePrototypes;
dest.wavingGrassAmount = source.wavingGrassAmount;
dest.wavingGrassSpeed = source.wavingGrassSpeed;
dest.wavingGrassStrength = source.wavingGrassStrength;
dest.wavingGrassTint = source.wavingGrassTint;
return dest;
}
private void ResizeDetailResolution(TerrainData terrainData, int resolution, int resolutionPerPatch)
{
if (resolution == terrainData.detailResolution)
{
List<int[,]> numArrayList = new List<int[,]>();
for (int layer = 0; layer < terrainData.detailPrototypes.Length; ++layer)
numArrayList.Add(terrainData.GetDetailLayer(0, 0, terrainData.detailWidth, terrainData.detailHeight, layer));
terrainData.SetDetailResolution(resolution, resolutionPerPatch);
for (int layer = 0; layer < numArrayList.Count; ++layer)
terrainData.SetDetailLayer(0, 0, layer, numArrayList[layer]);
}
else
terrainData.SetDetailResolution(resolution, resolutionPerPatch);
}
public void PlaceDetails(ProgressDetailsDelegate progressDelegate)
{
Terrain ter = (Terrain) GetComponent(typeof(Terrain));
terrainData = ter.terrainData;
int alphamapWidth = terrainData.alphamapWidth;
int alphamapHeight = terrainData.alphamapHeight;
int detailWidth = terrainData.detailResolution;
int detailHeight = detailWidth;
float resolutionDiffFactor = (float)alphamapWidth/detailWidth;
float[,,] splatmap = terrainData.GetAlphamaps(0,0,alphamapWidth,alphamapHeight);
float alphaValue = 0;
int count = terrainData.detailPrototypes.Length * DetailPlacement.Textures.Count;
float increment = 1 / count;
float percentCompleted = 0.0f;
//how big is one unit in real world
xUnit = (float)terrainData.size.x / (float)(detailWidth);
yUnit = (float)terrainData.size.z / (float)(detailHeight);
System.Random random = new System.Random();
int randomInt;
for(int detailIndex = 0; detailIndex < terrainData.detailPrototypes.Length; detailIndex++)
{
int[,] newDetailLayer = new int[detailWidth,detailHeight];
foreach(DetailTextureSettings texture in DetailPlacement.Textures)
{
DetailSettings ds = texture.Details[detailIndex];
ds.MinimumHeight = (int)ds.MinHeight;
ds.MaximumHeight = (int)ds.MaxHeight;
percentCompleted += increment;
progressDelegate("Placing details", "Placing details", percentCompleted);
if (ds.IsUsed == false)
continue;
//find where the texture is present
for (int j = 0; j < detailWidth; j++)
{
for (int k = 0; k < detailHeight; k++)
{
alphaValue = splatmap[(int)(resolutionDiffFactor*j),(int)(resolutionDiffFactor*k),texture.Index];
if (alphaValue >= ds.AlphamapValue && !ds.FluentCoverage)
{
//recalculate this position to real height
//also check if minimum height is allowed for this texture
if (CalculateHeight(ter, j, k, ds))
{
//rare plant is only low chance
if (ds.Rare)
{
randomInt = random.Next(ds.ChanceToFind);
if (randomInt == 1)
newDetailLayer[j,k] = ds.Intensity;
else
newDetailLayer[j,k] = 0;
}
else
{
newDetailLayer[j,k] = ds.Intensity;
}
}
else
{
newDetailLayer[j,k] = 0;
}
}
else if (ds.FluentCoverage && alphaValue >= ds.AlphamapValue)
{
if (!CalculateHeight(ter, j, k, ds))
{
newDetailLayer[j,k] = 0;
continue;
}
float wholeCoverage = 1 - ds.AlphamapValue;
float partCoverage = 1 - alphaValue;
int intensity = 1;
if (wholeCoverage != 0 && partCoverage != 0)
{
float percent = (wholeCoverage * 100) / partCoverage - 100;
intensity = (int)(ds.Intensity * percent / 100 / ds.Smoothness);
if (intensity == 0)
intensity = 1;
if (intensity > ds.Intensity)
intensity = ds.Intensity;
}
if (alphaValue == 1 || ds.AlphamapValue == 1)
intensity = ds.Intensity;
newDetailLayer[j,k] = intensity;
}
}
}
}
terrainData.SetDetailLayer(0,0,detailIndex,newDetailLayer);
}
}
/// <summary>
/// Create terrain for the given tile
/// </summary>
private Terrain CreateTerrainTile(int x, int z)
{
float height = _terrainSettings.TerrainHeight;
var centerTile = x == (_tilesX / 2) && z == (_tilesZ / 2);
//Create terrain data and set prototypes
var data = new TerrainData
{
heightmapResolution = _terrainSettings.HeightmapSize,
alphamapResolution = _terrainSettings.AlphamapSize,
size = new Vector3(_terrainSize, height, _terrainSize),
splatPrototypes = _splatPrototypes,
treePrototypes = _treePrototypes,
detailPrototypes = _detailPrototypes
};
//Generate heightmap
data.SetHeights(0, 0, GenerateHeightMap(x, z));
//create terrain gameobject and position it correctly
var xPos = _terrainSize * x + _terrainOffset.x;
var zPos = _terrainSize * z + _terrainOffset.y;
var terrain = Terrain.CreateTerrainGameObject(data).GetComponent<Terrain>();
terrain.transform.position = new Vector3(xPos, 0, zPos);
terrain.gameObject.SetParent(_terrainGameObject);
terrain.name = string.Format("tile{0}x{1}", x, z);
terrain.castShadows = false;
terrain.detailObjectDensity = _terrainSettings.GrassDensity;
terrain.detailObjectDistance = 200.0f;
terrain.treeDistance = 1000.0f;
terrain.treeBillboardDistance = 400.0f;
terrain.treeCrossFadeLength = 20.0f;
terrain.treeMaximumFullLODCount = 400;
//Generate trees
if (!centerTile)
{
//Possibly generate some lakes
var rng = Random.value;
if (_terrainSettings.GenerateLake && rng < 0.75f)
{
var it = Random.Range(1, 4);
for (int i = 0; i < it; i++)
{
//add a lake o the terrain with a random size
AddLake(terrain, x, z, Random.Range(25, 60));
}
}
var trees = GenerateTrees(data, x, z);
if (trees != null)
{
foreach (var tree in trees)
{
terrain.AddTreeInstance(tree);
}
}
}
//Generate alphamap if valid
var alphamap = GenerateAlphaMap(data);
if (alphamap != null)
{
data.SetAlphamaps(0, 0, alphamap);
}
//Generate Detailsmap if valid for every layer
var detailLayers = GenerateDetailLayers(data, x, z);
if (detailLayers != null)
{
//set some detail settings
data.SetDetailResolution(_terrainSettings.DetailMapSize, _terrainSettings.DetailResolution);
data.wavingGrassStrength = 0.1f;
data.wavingGrassAmount = 0.1f;
data.wavingGrassSpeed = 0.2f;
data.wavingGrassTint = Color.white;
for (int layer = 0; layer < detailLayers.Count; ++layer)
{
data.SetDetailLayer(0, 0, layer, detailLayers[layer]);
}
}
//make sure the changes are updated
terrain.Flush();
return terrain;
}
// Add Grass
private void AddGrass(DaggerfallTerrain daggerTerrain, TerrainData terrainData)
{
// Used to check performance
// Stopwatch stopwatch = new Stopwatch();
// stopwatch.Start();
details = new int[256, 256];
//Get the current season
currentSeason = DaggerfallUnity.Instance.WorldTime.Now.SeasonValue;
//Proceed if it's NOT winter, and if the worldClimate contains grass, which is everything above 225, with the exception of 229
if (currentSeason != DaggerfallDateTime.Seasons.Winter && (daggerTerrain.MapData.worldClimate > 225 && daggerTerrain.MapData.worldClimate != 229))
{
//Switch the grass texture based on the climate
if (daggerTerrain.MapData.worldClimate == 226 || daggerTerrain.MapData.worldClimate == 227 || daggerTerrain.MapData.worldClimate == 228 || daggerTerrain.MapData.worldClimate == 230)
detailPrototype[0].prototypeTexture = brownGrass;
else
detailPrototype[0].prototypeTexture = greenGrass;
tilemap = daggerTerrain.TileMap;
terrainData.detailPrototypes = detailPrototype;
terrainData.wavingGrassTint = Color.gray;
terrainData.SetDetailResolution(256, 8);
int colorValue;
//Check all the tiles, Daggerfall uses the red color value to draw tiles
for (int i = 0; i < 128; i++)
{
for (int j = 0; j < 128; j++)
{
colorValue = tilemap[(i * 128) + j].r; //For easier checking
switch (colorValue)
{
//Four corner tiles
case 8:
case 9:
case 10:
case 11:
details[i * 2, j * 2] = Random.Range(thickLower, thickHigher);
details[i * 2, (j * 2) + 1] = Random.Range(thickLower, thickHigher);
details[(i * 2) + 1, j * 2] = Random.Range(thickLower, thickHigher);
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thickLower, thickHigher);
break;
//Upper left corner
case 40:
case 224:
case 164:
case 176:
case 181:
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
break;
//Lower left corner
case 41:
case 221:
case 165:
case 177:
case 182:
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
break;
//Lower right corner
case 42:
case 222:
case 166:
case 178:
case 183:
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//Upper right corner
case 43:
case 223:
case 167:
case 179:
case 180:
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//Left side
case 44:
case 66:
case 84:
case 160:
case 168:
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
break;
//lower side
case 45:
case 67:
case 85:
case 161:
case 169:
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
break;
//right side
case 46:
case 64:
case 86:
case 162:
case 170:
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//upper side
case 47:
case 65:
case 87:
case 163:
case 171:
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
break;
//All expect lower right
case 48:
case 62:
case 88:
case 156:
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//All expect upper right
case 49:
case 63:
case 89:
case 157:
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
break;
//All expect upper left
case 50:
case 60:
case 90:
case 158:
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//All expect lower left
case 51:
case 61:
case 91:
case 159:
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//Left to right
case 204:
case 206:
case 214:
details[i * 2, j * 2] = Random.Range(thinLower, thinHigher);
details[(i * 2) + 1, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
//Right to left
case 205:
case 207:
case 213:
details[(i * 2) + 1, j * 2] = Random.Range(thinLower, thinHigher);
details[i * 2, (j * 2) + 1] = Random.Range(thinLower, thinHigher);
break;
}
}
}
}
terrainData.SetDetailLayer(0, 0, 0, details);
// stopwatch.Stop();
// // Write result
// UnityEngine.Debug.Log("Time elapsed: " +
// stopwatch.Elapsed);
}
private void CreateLand()
{
#region Preparations
var mapData = Data.Battle["gamebody"]["map_info"]["types"];
var worldSize = realMapSize * Settings.DimensionScaleFactor;
var resolution = Mathf.RoundToInt(Mathf.Sqrt(realMapSize.x * realMapSize.y) * Settings.Terrain.Smoothness);
var terrainData = new TerrainData { heightmapResolution = Mathf.ClosestPowerOfTwo(resolution) + 1, size = new Vector3(worldSize.y, Settings.Map.HeightOfLevel[2], worldSize.x), alphamapResolution = resolution, baseMapResolution = resolution };
#endregion
#region Set Heights
float landArea = 0;
var heights = new float[terrainData.heightmapHeight, terrainData.heightmapWidth];
var mapRect = new Rect(0, 0, Data.MapSize.x, Data.MapSize.y);
for (int bumpNum = Mathf.RoundToInt(realMapSize.x * realMapSize.y / 10), i = 0; i < bumpNum; ++i)
{
var sigmaX = Random.Range(0.8f, 2) * terrainData.heightmapHeight / realMapSize.x;
var sigmaY = Random.Range(0.8f, 2) * terrainData.heightmapWidth / realMapSize.y;
var muX = Random.Range(0, terrainData.heightmapHeight);
var muY = Random.Range(0, terrainData.heightmapWidth);
var h = Random.Range(-0.6f, 0.4f);
for (var x = Mathf.Max(-muX, -Mathf.RoundToInt(sigmaX * 3)); x < Mathf.Min(terrainData.heightmapHeight - muX, Mathf.RoundToInt(sigmaX * 3)); ++x)
for (var y = Mathf.Max(-muY, -Mathf.RoundToInt(sigmaY * 3)); y < Mathf.Min(terrainData.heightmapWidth - muY, Mathf.RoundToInt(sigmaY * 3)); ++y)
heights[muX + x, muY + y] += h * Mathf.Exp(-Mathf.Pow(x / sigmaX, 2) - Mathf.Pow(y / sigmaY, 2));
}
var threshold = Settings.Map.HeightOfLevel[0] / Settings.Map.HeightOfLevel[2] * 0.8f;
for (var x = 0; x < terrainData.heightmapHeight; ++x)
for (var y = 0; y < terrainData.heightmapWidth; ++y)
{
if ((heights[x, y] += threshold / 2) > threshold)
heights[x, y] = threshold;
var i = (float)x / (terrainData.heightmapHeight - 1) * realMapSize.x - Settings.Map.MapSizeOffset.top;
var j = (1 - (float)y / (terrainData.heightmapWidth - 1)) * realMapSize.y - Settings.Map.MapSizeOffset.left;
int i0 = Mathf.FloorToInt(i), j0 = Mathf.FloorToInt(j);
float ul = 0, ur = 0, br = 0, bl = 0, di = i - i0, dj = j - j0;
if (mapRect.Contains(new Vector2(i0, j0)))
ul = mapData[i0][j0].n;
if (mapRect.Contains(new Vector2(i0, j0 + 1)))
ur = mapData[i0][j0 + 1].n;
if (mapRect.Contains(new Vector2(i0 + 1, j0 + 1)))
br = mapData[i0 + 1][j0 + 1].n;
if (mapRect.Contains(new Vector2(i0 + 1, j0)))
bl = mapData[i0 + 1][j0].n;
var height = (1 - di) * (1 - dj) * ul + (1 - di) * dj * ur + di * (1 - dj) * bl + di * dj * br;
if (Math.Abs(height) < Mathf.Epsilon)
continue;
heights[x, y] = Mathf.Max(heights[x, y], height = Mathf.Sign(height - 0.5f) * Mathf.Pow(Mathf.Abs(height * 2 - 1), 0.25f) / 2 + 0.5f);
landArea += height;
}
terrainData.SetHeights(0, 0, heights);
landArea *= realMapSize.x * realMapSize.y / (terrainData.heightmapHeight * terrainData.heightmapWidth);
#endregion
#region Paint Texture
var splatPrototypes = new SplatPrototype[splatTextures.Length];
for (var i = 0; i < splatPrototypes.Length; i++)
{
var splatPrototype = new SplatPrototype { texture = splatTextures[i], tileSize = Vector2.one * Settings.DimensionScaleFactor * 4 };
splatPrototypes[i] = splatPrototype;
}
terrainData.splatPrototypes = splatPrototypes;
var alphamapResolution = terrainData.alphamapResolution;
var alphamaps = new float[alphamapResolution, alphamapResolution, splatPrototypes.Length];
for (var i = 0; i < alphamapResolution; i++)
for (var j = 0; j < alphamapResolution; j++)
{
var height = heights[Mathf.RoundToInt((float)i / (alphamapResolution - 1) * (terrainData.heightmapHeight - 1)), Mathf.RoundToInt((float)j / (alphamapResolution - 1) * (terrainData.heightmapWidth - 1))];
alphamaps[i, j, 0] = height;
alphamaps[i, j, 1] = 1 - height;
}
terrainData.SetAlphamaps(0, 0, alphamaps);
#endregion
#region Place Trees
var treePrototypes = new TreePrototype[treePrefabs.Length];
for (var i = 0; i < treePrototypes.Length; i++)
{
var treePrototype = new TreePrototype { prefab = treePrefabs[i], bendFactor = 1 };
treePrototypes[i] = treePrototype;
}
terrainData.treePrototypes = treePrototypes;
var treeInstances = new TreeInstance[Mathf.RoundToInt(landArea * Settings.Terrain.Tree.Density)];
var range = new Vector4(Settings.Map.MapSizeOffset.right / realMapSize.y, 1 - Settings.Map.MapSizeOffset.left / realMapSize.y, Settings.Map.MapSizeOffset.top / realMapSize.x, 1 - Settings.Map.MapSizeOffset.bottom / realMapSize.x);
for (var i = 0; i < treeInstances.Length; i++)
{
var treeScale = Random.Range(0.08f, 0.16f) * Settings.DimensionScaleFactor;
Vector3 treePosition;
do
treePosition = new Vector3(Random.Range(range.x, range.y), 0, Random.Range(range.z, range.w));
while ((treePosition.y = heights[Mathf.RoundToInt(treePosition.z * (terrainData.heightmapHeight - 1)), Mathf.RoundToInt(treePosition.x * (terrainData.heightmapWidth - 1))]) < Mathf.Lerp(Settings.Map.HeightOfLevel[1] / Settings.Map.HeightOfLevel[2], 1, 0.6f) || Methods.Coordinates.IsOccupied(Methods.Coordinates.InternalToExternal(Vector3.Scale(treePosition, new Vector3(worldSize.y, 0, worldSize.x)))));
var treeInstance = new TreeInstance { prototypeIndex = Random.Range(0, treePrototypes.Length), position = treePosition + Vector3.up * Settings.Terrain.Tree.VerticalPositionOffset * treeScale, color = new Color(0, 0.8f, 0, 1), lightmapColor = new Color(1, 1, 1, 1), heightScale = treeScale, widthScale = treeScale };
treeInstances[i] = treeInstance;
}
terrainData.treeInstances = treeInstances;
#endregion
#region Paint Details
var detailPrototypes = new DetailPrototype[detailTextures.Length];
for (var i = 0; i < detailPrototypes.Length; i++)
{
var detailPrototype = new DetailPrototype { prototypeTexture = detailTextures[i], minWidth = Settings.Terrain.Detail.MinDimension, minHeight = Settings.Terrain.Detail.MinDimension, maxWidth = Settings.Terrain.Detail.MaxDimension, maxHeight = Settings.Terrain.Detail.MaxDimension, renderMode = DetailRenderMode.GrassBillboard };
detailPrototypes[i] = detailPrototype;
}
terrainData.detailPrototypes = detailPrototypes;
terrainData.SetDetailResolution(resolution, Mathf.Clamp(resolution, 8, 128));
var detailLayers = new int[detailPrototypes.Length][,];
for (var i = 0; i < detailPrototypes.Length; i++)
detailLayers[i] = new int[terrainData.detailResolution, terrainData.detailResolution];
for (var i = 0; i < terrainData.detailResolution; i++)
for (var j = 0; j < terrainData.detailResolution; j++)
{
var layer = Random.Range(0, detailPrototypes.Length);
var height = heights[Mathf.RoundToInt((float)i / (terrainData.detailResolution - 1) * (terrainData.heightmapHeight - 1)), Mathf.RoundToInt((float)j / (terrainData.detailResolution - 1) * (terrainData.heightmapWidth - 1))];
if (height > Mathf.Lerp(Settings.Map.HeightOfLevel[1] / Settings.Map.HeightOfLevel[2], 1, 0.4f))
detailLayers[layer][i, j] = 1;
}
for (var i = 0; i < detailPrototypes.Length; i++)
terrainData.SetDetailLayer(0, 0, i, detailLayers[i]);
terrainData.wavingGrassAmount = Settings.Terrain.Detail.Waving.Amount;
terrainData.wavingGrassSpeed = Settings.Terrain.Detail.Waving.Speed;
terrainData.wavingGrassStrength = Settings.Terrain.Detail.Waving.Strength;
#endregion
#region Final Settings
var terrain = Terrain.CreateTerrainGameObject(terrainData).GetComponent<Terrain>();
terrain.treeBillboardDistance = Settings.Terrain.Tree.BillboardDistance;
terrain.detailObjectDistance = Settings.Terrain.Detail.MaxVisibleDistance;
terrain.detailObjectDensity = Settings.Terrain.Detail.Density;
#endregion
}
public static void reRes(GameObject go,int detailRes, int heightRes, int alphaRes)
{
TerrainData tdat = go.GetComponent<Terrain>().terrainData;
TerrainData terrainData = new TerrainData();
string goName = go.name+"_new";
string terName = tdat.name;
terrainData.heightmapResolution = heightRes;
terrainData.alphamapResolution = alphaRes;
terrainData.SetDetailResolution(detailRes,8);
terrainData.baseMapResolution = tdat.baseMapResolution;
terrainData.detailPrototypes = tdat.detailPrototypes;
terrainData.splatPrototypes = tdat.splatPrototypes;
terrainData.treePrototypes = tdat.treePrototypes;
terrainData.treeInstances = tdat.treeInstances;
terrainData.size = tdat.size;
terrainData.RefreshPrototypes();
GameObject terrObj = Terrain.CreateTerrainGameObject(terrainData);
terrObj.transform.position=new Vector3(0f,0f,0f);
terrObj.name = goName;
terrObj.GetComponent<Terrain>().Flush();
float mult = 0.0f;
int destres = 0;
destres = detailRes;
int[,] detaildatasource = new int[tdat.detailResolution,tdat.detailResolution];
int[,] detaildatadest = new int[destres,destres];
for(int layer=0; layer<tdat.detailPrototypes.Length; layer++){
detaildatasource = tdat.GetDetailLayer(0,0,tdat.detailResolution,tdat.detailResolution,layer);
mult=(float)tdat.detailResolution/(float)destres;
for(int y=0;y<destres;y++){
for(int x=0;x<destres;x++){
int xold = (int)(mult * (float)x);
int yold = (int)(mult * (float)y);
detaildatadest[x,y]=detaildatasource[xold,yold];
}
}
terrainData.SetDetailLayer(0,0,layer,detaildatadest);
}
destres = heightRes;
float[,] heightdatasource = new float[tdat.heightmapResolution,tdat.heightmapResolution];
float[,] heightdatadest = new float[destres,destres];
heightdatasource = tdat.GetHeights(0,0,tdat.heightmapResolution,tdat.heightmapResolution);
mult=((float)tdat.heightmapResolution-1.0f)/((float)destres-1.0f);
for(int y=0;y<destres;y++){
for(int x=0;x<destres;x++){
int xold = (int)(mult * (float)x);
int yold = (int)(mult * (float)y);
heightdatadest[x,y]=heightdatasource[xold,yold];
}
}
destres = alphaRes;
float[,,] alphadata = tdat.GetAlphamaps(0,0,tdat.alphamapResolution,tdat.alphamapResolution);
float[,,] alphadatadest = new float[destres,destres,tdat.splatPrototypes.Length];
mult=(float)tdat.alphamapResolution/(float)destres;
for(int i=0;i<tdat.splatPrototypes.Length;i++){
for(int y=0;y<destres;y++){
for(int x=0;x<destres;x++){
int xold = (int)(mult * (float)x);
int yold = (int)(mult * (float)y);
alphadatadest[x,y,i] = alphadata[xold,yold,i];
}
}
}
terrObj.GetComponent<Terrain>().terrainData.SetHeights(0,0,heightdatadest);
AssetDatabase.CreateAsset(terrainData, "Assets/"+terName+"_new.asset");
AssetDatabase.SaveAssets();
TerrainData terrainData2Splat = (TerrainData)AssetDatabase.LoadAssetAtPath("Assets/"+terName+"_new.asset", typeof(TerrainData));
terrainData2Splat.splatPrototypes = tdat.splatPrototypes;
terrainData2Splat.RefreshPrototypes();
terrainData2Splat.SetAlphamaps (0, 0, alphadatadest);
AssetDatabase.SaveAssets();
go.active = false;
}
