private void DoApply()
{
if (base.terrainData != null)
{
TreePrototype[] treePrototypes = base.m_Terrain.terrainData.treePrototypes;
if (this.m_PrototypeIndex == -1)
{
TreePrototype[] prototypeArray2 = new TreePrototype[treePrototypes.Length + 1];
for (int i = 0; i < treePrototypes.Length; i++)
{
prototypeArray2[i] = treePrototypes[i];
}
prototypeArray2[treePrototypes.Length] = new TreePrototype();
prototypeArray2[treePrototypes.Length].prefab = this.m_Tree;
prototypeArray2[treePrototypes.Length].bendFactor = this.m_BendFactor;
this.m_PrototypeIndex = treePrototypes.Length;
base.m_Terrain.terrainData.treePrototypes = prototypeArray2;
TreePainter.selectedTree = this.m_PrototypeIndex;
}
else
{
treePrototypes[this.m_PrototypeIndex].prefab = this.m_Tree;
treePrototypes[this.m_PrototypeIndex].bendFactor = this.m_BendFactor;
base.m_Terrain.terrainData.treePrototypes = treePrototypes;
}
base.m_Terrain.Flush();
EditorUtility.SetDirty(base.m_Terrain);
}
}
private void DoApply()
{
if ((Object) this.terrainData == (Object) null)
return;
TreePrototype[] treePrototypes = this.m_Terrain.terrainData.treePrototypes;
if (this.m_PrototypeIndex == -1)
{
TreePrototype[] treePrototypeArray = new TreePrototype[treePrototypes.Length + 1];
for (int index = 0; index < treePrototypes.Length; ++index)
treePrototypeArray[index] = treePrototypes[index];
treePrototypeArray[treePrototypes.Length] = new TreePrototype();
treePrototypeArray[treePrototypes.Length].prefab = this.m_Tree;
treePrototypeArray[treePrototypes.Length].bendFactor = this.m_BendFactor;
this.m_PrototypeIndex = treePrototypes.Length;
this.m_Terrain.terrainData.treePrototypes = treePrototypeArray;
TreePainter.selectedTree = this.m_PrototypeIndex;
}
else
{
treePrototypes[this.m_PrototypeIndex].prefab = this.m_Tree;
treePrototypes[this.m_PrototypeIndex].bendFactor = this.m_BendFactor;
this.m_Terrain.terrainData.treePrototypes = treePrototypes;
}
this.m_Terrain.Flush();
EditorUtility.SetDirty((Object) this.m_Terrain);
}
private bool Equals(TreePrototype other)
{
bool flag = other == null;
bool result;
if (flag)
{
result = false;
}
else
{
bool flag2 = other == this;
if (flag2)
{
result = true;
}
else
{
bool flag3 = base.GetType() != other.GetType();
if (flag3)
{
result = false;
}
else
{
bool flag4 = this.prefab == other.prefab && this.bendFactor == other.bendFactor && this.navMeshLod == other.navMeshLod;
result = flag4;
}
}
}
return(result);
}
private void DoApply()
{
if (base.terrainData == null)
{
return;
}
TreePrototype[] treePrototypes = this.m_Terrain.terrainData.treePrototypes;
if (this.m_PrototypeIndex == -1)
{
TreePrototype[] array = new TreePrototype[treePrototypes.Length + 1];
for (int i = 0; i < treePrototypes.Length; i++)
{
array[i] = treePrototypes[i];
}
array[treePrototypes.Length] = new TreePrototype();
array[treePrototypes.Length].prefab = this.m_Tree;
array[treePrototypes.Length].bendFactor = this.m_BendFactor;
this.m_PrototypeIndex = treePrototypes.Length;
this.m_Terrain.terrainData.treePrototypes = array;
}
else
{
treePrototypes[this.m_PrototypeIndex].prefab = this.m_Tree;
treePrototypes[this.m_PrototypeIndex].bendFactor = this.m_BendFactor;
this.m_Terrain.terrainData.treePrototypes = treePrototypes;
}
this.m_Terrain.Flush();
EditorUtility.SetDirty(this.m_Terrain);
}
public static void ClearTrees()
{
Terrain t = Terrain.activeTerrain;
TerrainData td = t.terrainData;
TreePrototype[] treeprototypes = new TreePrototype[0];
td.treePrototypes = treeprototypes;
}
private bool Equals(TreePrototype other)
{
if (ReferenceEquals(other, null))
{
return(false);
}
if (ReferenceEquals(other, this))
{
return(true);
}
if (GetType() != other.GetType())
{
return(false);
}
bool equals = prefab == other.prefab &&
bendFactor == other.bendFactor;
return(equals);
}
/// <summary>
/// Read the data into the specified value.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="reader">Reader.</param>
public override void ReadInto(object value, ISaveGameReader reader)
{
UnityEngine.TreePrototype treePrototype = (UnityEngine.TreePrototype)value;
foreach (string property in reader.Properties)
{
switch (property)
{
case "prefab":
if (treePrototype.prefab == null)
{
treePrototype.prefab = reader.ReadProperty <UnityEngine.GameObject> ();
}
else
{
reader.ReadIntoProperty <UnityEngine.GameObject> (treePrototype.prefab);
}
break;
case "bendFactor":
treePrototype.bendFactor = reader.ReadProperty <System.Single> ();
break;
}
}
}
private static void GenerateTrees()
{
Terrain t = Terrain.activeTerrain;
TerrainData td = t.terrainData;
TreePrototype[] treeprototypes = new TreePrototype[] { new TreePrototype() { prefab = (GameObject)Resources.Load("BigTree") }, new TreePrototype() { prefab = (GameObject)Resources.Load("Tree") } };
td.treePrototypes = treeprototypes;
//float[, ,] splatmaps = td.GetAlphamaps(0, 0, td.alphamapWidth, td.alphamapHeight);
td.treeInstances = new TreeInstance[0];
List<Vector3> treePos = new List<Vector3>();
float[,] noisemap = new float[td.alphamapWidth, td.alphamapHeight];
Generator noise_tree = new Max(
new PinkNoise((int)UnityEngine.Random.Range(0, int.MaxValue)) { Frequency = 0.01f, OctaveCount = 6, Persistence = 0.66f, Lacunarity = 0.1f },
new PinkNoise((int)UnityEngine.Random.Range(0, int.MaxValue)) { Frequency = 0.015f, OctaveCount = 2, Persistence = 0.66f, Lacunarity = 0.2f });
for (int ny = 0; ny < noisemap.GetLength(1); ny++)
{
for (int nx = 0; nx < noisemap.GetLength(0); nx++)
{
noisemap[nx, ny] = noise_tree.GetValue(nx, ny, 0);
}
}
if (maxSteepness == 0) { maxSteepness = 70.0f; }
if (waterLevel == 0) { waterLevel = 0.0f; }
float x = 0.0f;
while (x < td.alphamapWidth)
{
float y = 0.0f;
while (y < td.alphamapHeight)
{
float height = td.GetHeight((int)x, (int)y);
float heightScaled = height / td.size.y;
float xScaled = (x + Random.Range(-1f, 1f)) / td.alphamapWidth;
float yScaled = (y + Random.Range(-1f, 1f)) / td.alphamapHeight;
float steepness = td.GetSteepness(xScaled, yScaled);
if (Random.Range(0f, 1f) > 1f - noisemap[(int)x, (int)y] * 2f && steepness < maxSteepness && height > waterLevel)
{
treePos.Add(new Vector3(xScaled, heightScaled, yScaled));
}
y++;
}
x++;
}
TreeInstance[] treeInstances = new TreeInstance[treePos.Count];
for (int ii = 0; ii < treeInstances.Length; ii++)
{
treeInstances[ii].position = treePos[ii];
treeInstances[ii].prototypeIndex = Random.Range(0, treeprototypes.Length);
treeInstances[ii].color = Color.white;//new Color(Random.Range(200, 255), Random.Range(200, 255), Random.Range(200, 255));
treeInstances[ii].lightmapColor = Color.white;
treeInstances[ii].heightScale = 1.0f + Random.Range(-0.25f, 0.5f);
treeInstances[ii].widthScale = 1.0f + Random.Range(-0.5f, 0.25f);
}
td.treeInstances = treeInstances;
}
/// <summary>
/// Read the data using the reader.
/// </summary>
/// <param name="reader">Reader.</param>
public override object Read(ISaveGameReader reader)
{
UnityEngine.TreePrototype treePrototype = new UnityEngine.TreePrototype();
ReadInto(treePrototype, reader);
return(treePrototype);
}
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 TreePrototype(TreePrototype other)
{
prefab = other.prefab;
bendFactor = other.bendFactor;
navMeshLod = other.navMeshLod;
}
TreePrototype[] SetupTrees()
{
TreePrototype[] Trees = new TreePrototype[3];
Trees[0] = new TreePrototype();
Trees[0].prefab = TreeObj[0];
Trees[1] = new TreePrototype();
Trees[1].prefab = TreeObj[1];
Trees[2] = new TreePrototype();
Trees[2].prefab = TreeObj[2];
return Trees;
}
TreePrototype BlueprintToTreePrototype(TreeBlueprint blueprint)
{
TreePrototype prototype = new TreePrototype();
prototype.prefab = blueprint.prefab;
prototype.bendFactor = blueprint.bendFactor;
return prototype;
}
/// <summary>
/// Create splatmaps, trees and detail prototypes
/// </summary>
private void CreatePrototypes()
{
//Create splatmap prototypes
var splats = new List<SplatPrototype>();
foreach (var tex in _terrainSettings.SplatMaps)
{
//make sure the texture is valid
if (tex == null) continue;
var splat = new SplatPrototype()
{
texture = tex.Texture,
tileSize = new Vector2(tex.TileSize, tex.TileSize)
};
splats.Add(splat);
}
//store it
_splatPrototypes = splats.ToArray();
//create tree prototypes
var trees = new List<TreePrototype>();
foreach (var prefab in _terrainSettings.Trees)
{
if (prefab == null) continue;
var treeProto = new TreePrototype
{
prefab = prefab
};
trees.Add(treeProto);
}
_treePrototypes = trees.ToArray();
//Sort the detail list based on type ( textures < prefabs)
var detailPrefabs = _terrainSettings.Details;
detailPrefabs = detailPrefabs.SortByType();
//create detail prototypes textures
var details = new List<DetailPrototype>();
foreach (var d in detailPrefabs)
{
if (d == null) continue;
var detail = new DetailPrototype
{
healthyColor = Color.white,
dryColor = Color.white,
maxHeight = 0.8f,
maxWidth = 1.0f
};
//set correct data based on type
switch (d.Type)
{
case DetailType.Texture:
{
detail.renderMode = DetailRenderMode.GrassBillboard;
detail.prototypeTexture = (Texture2D)d.Detail;
_grassLayers++;
break;
}
case DetailType.GameObject:
{
detail.renderMode = DetailRenderMode.VertexLit;
detail.prototype = (GameObject)d.Detail;
detail.usePrototypeMesh = true;
_meshLayers++;
break;
}
}
//Add the detail
details.Add(detail);
}
_detailPrototypes = details.ToArray();
//notify user of any missed prototypes
if (_splatPrototypes.Length < 1)
{
Debug.LogWarning("Unable to generate terrain textures\nPlease specify textures to use for the terrain.");
}
if (_treePrototypes.Length == 0)
{
Debug.LogWarning("Unable to generate trees\nPlease specify prefabs to use for trees.");
}
if (_detailPrototypes.Length == 0)
{
Debug.LogWarning("Unable to generate details\nPlease specify prefabs to use for details.");
}
}
public TreePrototype(TreePrototype other)
{
this.prefab = other.prefab;
this.bendFactor = other.bendFactor;
this.navMeshLod = other.navMeshLod;
}
// Use this for initialization
void createTerrain () {
TerrainData terrainData = new TerrainData();
terrainData.heightmapResolution = m_heightMapSize;
terrainData.size = new Vector3(m_terrainSize, m_terrainHeight, m_terrainSize);
terrainData.alphamapResolution = m_alphaMapSize;
//add random points
for (int i=0; i< numPoints; i++) {
points.Add(new Vector2(Random.Range(10,m_heightMapSize-10),Random.Range(10,m_heightMapSize-10)));
}
/*
for (int i=0; i<20; i++)
for (int j=0; j<20;j++)
points.Add(new Vector2(m_terrainSize/20 * i, m_terrainSize/20*j));
*/
voronoi = new Voronoi (points, null, new Rect (0, 0, m_heightMapSize, m_heightMapSize));
buildGraph (points, voronoi);
m_groundNoise = new PerlinNoise(m_groundSeed);
m_mountainNoise = new PerlinNoise(m_mountainSeed);
m_treeNoise = new PerlinNoise(m_treeSeed);
m_islandNoise = new PerlinNoise (m_islandSeed);
htmap = new float[m_heightMapSize,m_heightMapSize];
getCenter = new Center[m_heightMapSize,m_heightMapSize];
m_terrain = new Terrain();
for (int i= 0; i < m_splats.Length ; i++) {
SplatPrototype splatPrototype = new SplatPrototype();
splatPrototype.texture = m_splats[i];
splatPrototype.tileSize = new Vector2 (2, 2);
m_splatPrototypes.Add( splatPrototype);
}
for (int i= 0; i < m_trees.Length ; i++) {
TreePrototype treePrototype = new TreePrototype();
treePrototype.prefab = m_trees[i];
m_treeProtoTypes.Add( treePrototype);
}
m_detailProtoTypes = new DetailPrototype[3];
m_detailProtoTypes[0] = new DetailPrototype();
m_detailProtoTypes[0].prototypeTexture = m_detail0;
m_detailProtoTypes[0].renderMode = detailMode;
m_detailProtoTypes[0].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[0].dryColor = m_grassDryColor;
m_detailProtoTypes[1] = new DetailPrototype();
m_detailProtoTypes[1].prototypeTexture = m_detail1;
m_detailProtoTypes[1].renderMode = detailMode;
m_detailProtoTypes[1].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[1].dryColor = m_grassDryColor;
m_detailProtoTypes[2] = new DetailPrototype();
m_detailProtoTypes[2].prototypeTexture = m_detail2;
m_detailProtoTypes[2].renderMode = detailMode;
m_detailProtoTypes[2].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[2].dryColor = m_grassDryColor;
//terrainData.detailPrototypes = m_detailProtoTypes;
terrainData.splatPrototypes = m_splatPrototypes.ToArray();
terrainData.treePrototypes = m_treeProtoTypes.ToArray();
terrainData.detailPrototypes = m_detailProtoTypes;
m_terrain = Terrain.CreateTerrainGameObject(terrainData).GetComponent<Terrain>();
m_terrain.tag = "ground";
FillHeights(htmap); // ovde je terren
terrainData.SetHeights(0, 0, htmap);
//float ratio = (float)(m_heightMapSize-1)/m_terrainSize;
foreach (Corner p in corners) {
Vector2 coords = new Vector2(p.point.x*m_terrainSize/m_heightMapSize,p.point.y*m_terrainSize/m_heightMapSize);
p.elevation = Terrain.activeTerrain.SampleHeight(new Vector3(coords.x,0.0f,coords.y));
p.elevation/= m_terrainHeight;
p.water = p.elevation < waterLimit; //* (heightMaximum - heightMinimum) + heightMinimum;
}
// foreach (Corner p in corners) {
//
//
//
// int elevX = (int) (p.point.x);
// int elevY = (int) (p.point.y);
//
// if (elevX == m_heightMapSize) elevX--;
// if (elevY == m_heightMapSize) elevY--;
//
// p.elevation = htmap [elevX, elevY] ;
//
// p.water = htmap[elevX, elevY] < waterLimit; //* (heightMaximum - heightMinimum) + heightMinimum;
//
// }
//create water
int size = (int) (m_terrainSize /2 * 1.41);
float waterLevel = m_terrainHeight * waterLimit;
GameObject water = (GameObject)Instantiate (waterTexture, new Vector3 (m_terrainSize /2, waterLevel, m_terrainSize /2), Quaternion.identity);
Vector3 v = water.transform.localScale;
water.transform.localScale = v + new Vector3 (size, 0, size);
assignOceanCoastAndLand ();
// foreach (Corner q in corners) {
// if (q.ocean || q.coast) {
// q.elevation = 0f;
// }
// }
for (int i=0; i <m_heightMapSize; i++)
for (int j=0; j<m_heightMapSize; j++)
getCenter [i, j] = centers [0];
fillCenters2 ();
assignPolygonElevations (htmap);
call ();
// foreach (Center center in centers)
// center.elevation = (center.elevation - heightMinimum) / (heightMaximum - heightMinimum);
assignBiomes ();
//FillAlphaMapByHeights (terrainData,htmap);
FillAlphaMapByBiomes (terrainData); // postavlja texture
m_terrain.transform.position = new Vector3(0, 0, 0);
//disable this for better frame rate
m_terrain.castShadows = false;
}
void Awake()
{
DontDestroyOnLoad(this);
random = new System.Random(Seed);
UnityEngine.Random.seed = DataBaseHandler.DataBase.Seed;
Foliage.Add(Resources.Load<GameObject>("Foliage/Palm"));
biomes.Add(new Arctic(Resources.Load<Texture2D>("Textures/Arctic_Diff"), Resources.Load<Texture2D>("Textures/Arctic_Norm"), BiomeTypes.Arctic,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Arctic_Tree1"),
Resources.Load<GameObject>("Foliage/Arctic_Tree2"),
Resources.Load<GameObject>("Foliage/Arctic_Tree3"),
Resources.Load<GameObject>("Foliage/Arctic_Tree4"),
Resources.Load<GameObject>("Foliage/Arctic_Tree5"),
Resources.Load<GameObject>("Foliage/Arctic_Tree6"),
Resources.Load<GameObject>("Foliage/Arctic_Tree7"),
Resources.Load<GameObject>("Foliage/Arctic_Tree8"),
},
new int[]
{
5,5,5,5,5,5,5,5,
}));
biomes.Add(new BorealForest(Resources.Load<Texture2D>("Textures/BorealForest_Diff"), Resources.Load<Texture2D>("Textures/BorealForest_Norm"), BiomeTypes.BorealForest,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/BorealForest_Tree1"),
Resources.Load<GameObject>("Foliage/BorealForest_Tree2"),
Resources.Load<GameObject>("Foliage/BorealForest_Tree3"),
Resources.Load<GameObject>("Foliage/BorealForest_Tree4"),
Resources.Load<GameObject>("Foliage/BorealForest_Tree5"),
},
new int[]
{
100,100,100,100,100
}));
biomes.Add(new Desert(Resources.Load<Texture2D>("Textures/Desert_Diff"), Resources.Load<Texture2D>("Textures/Desert_Norm"), BiomeTypes.Desert,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Desert_Tree1"),
Resources.Load<GameObject>("Foliage/Desert_Tree2"),
Resources.Load<GameObject>("Foliage/Desert_Tree3"),
},
new int[]
{
20,20,50,
}));
biomes.Add(new Forest(Resources.Load<Texture2D>("Textures/Forest_Diff"), Resources.Load<Texture2D>("Textures/Forest_Norm"), BiomeTypes.Forest,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Forest_Tree1"),
Resources.Load<GameObject>("Foliage/Forest_Tree2"),
Resources.Load<GameObject>("Foliage/Forest_Tree3"),
Resources.Load<GameObject>("Foliage/Forest_Tree4"),
Resources.Load<GameObject>("Foliage/Forest_Tree5"),
Resources.Load<GameObject>("Foliage/Forest_Tree6"),
Resources.Load<GameObject>("Foliage/Forest_Tree7"),
Resources.Load<GameObject>("Foliage/Forest_Tree8"),
Resources.Load<GameObject>("Foliage/Forest_Tree9"),
Resources.Load<GameObject>("Foliage/Forest_Tree10"),
Resources.Load<GameObject>("Foliage/Forest_Tree11"),
Resources.Load<GameObject>("Foliage/Forest_Tree12"),
Resources.Load<GameObject>("Foliage/Forest_Tree13"),
Resources.Load<GameObject>("Foliage/Forest_Tree14"),
Resources.Load<GameObject>("Foliage/Forest_Tree15"),
Resources.Load<GameObject>("Foliage/Forest_Tree16"),
Resources.Load<GameObject>("Foliage/Forest_Tree17"),
Resources.Load<GameObject>("Foliage/Forest_Tree18"),
},
new int[]
{
50,50,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,
}));
biomes.Add(new Prairie(Resources.Load<Texture2D>("Textures/Prairie_Diff"), Resources.Load<Texture2D>("Textures/Prairie_Norm"), BiomeTypes.Prairie,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Prairie_Tree1"),
Resources.Load<GameObject>("Foliage/Prairie_Tree2"),
Resources.Load<GameObject>("Foliage/Prairie_Tree3"),
Resources.Load<GameObject>("Foliage/Prairie_Tree4"),
Resources.Load<GameObject>("Foliage/Prairie_Tree5"),
Resources.Load<GameObject>("Foliage/Prairie_Tree6"),
Resources.Load<GameObject>("Foliage/Prairie_Tree7"),
Resources.Load<GameObject>("Foliage/Prairie_Tree8"),
Resources.Load<GameObject>("Foliage/Prairie_Tree9"),
Resources.Load<GameObject>("Foliage/Prairie_Tree10"),
},
new int[]
{
200,50,20,20,20,20,100,150,200,200,
}));
biomes.Add(new RainForest(Resources.Load<Texture2D>("Textures/RainForest_Diff"), Resources.Load<Texture2D>("Textures/RainForest_Norm"), BiomeTypes.RainForest,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/RainForest_Tree1"),
Resources.Load<GameObject>("Foliage/RainForest_Tree2"),
Resources.Load<GameObject>("Foliage/RainForest_Tree3"),
Resources.Load<GameObject>("Foliage/RainForest_Tree4"),
Resources.Load<GameObject>("Foliage/RainForest_Tree5"),
Resources.Load<GameObject>("Foliage/RainForest_Tree6"),
Resources.Load<GameObject>("Foliage/RainForest_Tree7"),
Resources.Load<GameObject>("Foliage/RainForest_Tree8"),
Resources.Load<GameObject>("Foliage/RainForest_Tree9"),
Resources.Load<GameObject>("Foliage/RainForest_Tree10"),
Resources.Load<GameObject>("Foliage/RainForest_Tree11"),
Resources.Load<GameObject>("Foliage/RainForest_Tree12"),
Resources.Load<GameObject>("Foliage/RainForest_Tree13"),
Resources.Load<GameObject>("Foliage/RainForest_Tree14"),
},
new int[]
{
100, 100, 25, 25, 40, 40, 40, 25, 25, 100, 100, 100, 30, 40,
}));
biomes.Add(new Savanna(Resources.Load<Texture2D>("Textures/Savanna_Diff"), Resources.Load<Texture2D>("Textures/Savanna_Norm"), BiomeTypes.Savanna,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Savanna_Tree1"),
Resources.Load<GameObject>("Foliage/Savanna_Tree2"),
Resources.Load<GameObject>("Foliage/Savanna_Tree3"),
Resources.Load<GameObject>("Foliage/Savanna_Tree4"),
Resources.Load<GameObject>("Foliage/Savanna_Tree5"),
Resources.Load<GameObject>("Foliage/Savanna_Tree6"),
Resources.Load<GameObject>("Foliage/Savanna_Tree7"),
Resources.Load<GameObject>("Foliage/Savanna_Tree8"),
},
new int[]
{
25,25,200,10,50,50,100,100,
}));
biomes.Add(new Taiga(Resources.Load<Texture2D>("Textures/Taiga_Diff"), Resources.Load<Texture2D>("Textures/Taiga_Norm"), BiomeTypes.Taiga,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Taiga_Tree1"),
Resources.Load<GameObject>("Foliage/Taiga_Tree2"),
Resources.Load<GameObject>("Foliage/Taiga_Tree3"),
Resources.Load<GameObject>("Foliage/Taiga_Tree4"),
Resources.Load<GameObject>("Foliage/Taiga_Tree5"),
Resources.Load<GameObject>("Foliage/Taiga_Tree6"),
Resources.Load<GameObject>("Foliage/Taiga_Tree7"),
Resources.Load<GameObject>("Foliage/Taiga_Tree8"),
},
new int[]
{
100, 50, 100, 50, 25, 25, 50, 50,
}));
biomes.Add(new Tundra(Resources.Load<Texture2D>("Textures/Tundra_Diff"), Resources.Load<Texture2D>("Textures/Tundra_Norm"), BiomeTypes.Tundra,
new GameObject[]
{
Resources.Load<GameObject>("Foliage/Tundra_Tree1"),
Resources.Load<GameObject>("Foliage/Tundra_Tree2"),
Resources.Load<GameObject>("Foliage/Tundra_Tree3"),
Resources.Load<GameObject>("Foliage/Tundra_Tree4"),
Resources.Load<GameObject>("Foliage/Tundra_Tree5"),
Resources.Load<GameObject>("Foliage/Tundra_Tree6"),
Resources.Load<GameObject>("Foliage/Tundra_Tree7"),
Resources.Load<GameObject>("Foliage/Tundra_Tree8"),
Resources.Load<GameObject>("Foliage/Tundra_Tree9"),
Resources.Load<GameObject>("Foliage/Tundra_Tree10"),
},
new int[]
{
10,10,10,10,10,10,10,10,25,25,
}));
SplatsPrototypes = new SplatPrototype[biomes.Count];
for (int i = 0; i < biomes.Count; i ++)
{
SplatPrototype sp = biomes[i].GetSplatPrototype();
sp.tileSize = new Vector2(16, 16);
SplatsPrototypes[i] = sp;
}
TreePrototypes = new TreePrototype[Foliage.Count];
for (int i = 0; i < Foliage.Count; i++)
{
TreePrototype tp = new TreePrototype();
tp.prefab = Foliage[i];
TreePrototypes[i] = tp;
}
}
//copying textures / details and tree prototypes
void Terrains()
{
EditorUtils.Label("Terrains");
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Source terrain");
sourceTerrain = EditorGUILayout.ObjectField(sourceTerrain, typeof(TerrainData), true) as TerrainData;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Target terrain");
targetTerrain = EditorGUILayout.ObjectField(targetTerrain, typeof(TerrainData), true) as TerrainData;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
EditorGUILayout.BeginHorizontal();
Undo.RegisterUndo(targetTerrain, "Copying trees, details and textures");
if (GUILayout.Button("Copy trees / details / textures"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
targetTerrain.detailPrototypes = sourceTerrain.detailPrototypes;
targetTerrain.treePrototypes = sourceTerrain.treePrototypes;
targetTerrain.splatPrototypes = sourceTerrain.splatPrototypes;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Only trees"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
targetTerrain.treePrototypes = sourceTerrain.treePrototypes;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Only details"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
targetTerrain.detailPrototypes = sourceTerrain.detailPrototypes;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Only textures"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
targetTerrain.splatPrototypes = sourceTerrain.splatPrototypes;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add trees"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
TreePrototype[] newArray = new TreePrototype[targetTerrain.treePrototypes.Length + sourceTerrain.treePrototypes.Length];
int currentIndex = 0;
foreach (TreePrototype tp in targetTerrain.treePrototypes)
{
newArray[currentIndex] = tp;
currentIndex++;
}
foreach (TreePrototype tp in sourceTerrain.treePrototypes)
{
newArray[currentIndex] = tp;
currentIndex++;
}
targetTerrain.treePrototypes = newArray;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add details"))
{
if (targetTerrain == null || sourceTerrain == null)
return;
DetailPrototype[] newArray = new DetailPrototype[targetTerrain.detailPrototypes.Length + sourceTerrain.detailPrototypes.Length];
int currentIndex = 0;
foreach (DetailPrototype tp in targetTerrain.detailPrototypes)
{
newArray[currentIndex] = tp;
currentIndex++;
}
foreach (DetailPrototype tp in sourceTerrain.detailPrototypes)
{
newArray[currentIndex] = tp;
currentIndex++;
}
targetTerrain.detailPrototypes = newArray;
}
EditorGUILayout.EndHorizontal();
}
void Awake()
{
splat[0] = Resources.Load("Textures/" + "rock_2048") as Texture2D;
splat[1] = Resources.Load("Textures/" + "forst_1024") as Texture2D;
splat[2] = Resources.Load("Textures/" + "snow_512") as Texture2D;
splat[3] = Resources.Load("Textures/" + "GoodDirt") as Texture2D;
detailTexture[0] = Resources.Load("Details/SimpleGrass/" + "Grass") as Texture2D;
detailTexture[1] = Resources.Load("Details/SimpleGrass/" + "WhiteFlowers") as Texture2D;
trees[0] = Resources.Load("Trees/" + "Tree4Master") as GameObject;
trees[1] = Resources.Load("Trees/" + "Tree5") as GameObject;
trees[2] = Resources.Load("Trees/" + "Tree4Master") as GameObject;
trees[3] = Resources.Load("Trees/" + "Bush1") as GameObject;
Vector2[] splatTileSize = new Vector2[4] { new Vector2(Tile0, Tile0), new Vector2(Tile1, Tile1), new Vector2(Tile2, Tile2), new Vector2(Tile3, Tile3) };
for (int i = 0; i < numOfSplatPrototypes; i++)
m_splatPrototypes[i] = new SplatPrototype();
for (int i = 0; i < numOfSplatPrototypes; i++)
{
m_splatPrototypes[i].texture = splat[i];
m_splatPrototypes[i].tileOffset = Vector2.zero;
m_splatPrototypes[i].tileSize = splatTileSize[i];
m_splatPrototypes[i].texture.Apply(true);
}
for (int i = 0; i < numOfDetailPrototypes; i++)
{
m_detailProtoTypes[i] = new DetailPrototype();
m_detailProtoTypes[i].prototypeTexture = detailTexture[i];
m_detailProtoTypes[i].renderMode = detailMode;
m_detailProtoTypes[i].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[i].dryColor = m_grassDryColor;
m_detailProtoTypes[i].maxHeight = 0.5f;
m_detailProtoTypes[i].maxWidth = 0.2f;
}
for (int i = 0; i < numOfTreePrototypes; i++)
{
m_treeProtoTypes[i] = new TreePrototype();
m_treeProtoTypes[i].prefab = trees[i];
}
for (int i = 0; i < dim; i++)
{
for (int j = 0; j < dim; j++)
{
TerrainData terrainData = new TerrainData();
terrainData.wavingGrassStrength = m_wavingGrassStrength;
terrainData.wavingGrassAmount = m_wavingGrassAmount;
terrainData.wavingGrassSpeed = m_wavingGrassSpeed;
terrainData.wavingGrassTint = m_wavingGrassTint;
terrainData.heightmapResolution = m_heightMapSize;
terrainData.size = new Vector3(m_landScapeSize, m_terrainHeight, m_landScapeSize);
terrainData.alphamapResolution = m_alphaMapSize;
terrainData.splatPrototypes = m_splatPrototypes;
terrainData.treePrototypes = m_treeProtoTypes;
terrainData.SetDetailResolution(m_detailMapSize, m_detailResolutionPerPatch);
terrainData.detailPrototypes = m_detailProtoTypes;
m_terrainGrid[i, j] = Terrain.CreateTerrainGameObject(terrainData).GetComponent<Terrain>();
}
}
for (int i = 0; i < dim; i++)
{
for (int j = 0; j < dim; j++)
{
m_terrainGrid[i, j].gameObject.AddComponent<TerrainScript>();
m_terrainGrid[i, j].transform.parent = gameObject.transform;
m_terrainGrid[i, j].transform.position = new Vector3(
m_terrainGrid[1, 1].transform.position.x + (i - 1) * m_landScapeSize, m_terrainGrid[1, 1].transform.position.y,
m_terrainGrid[1, 1].transform.position.z + (j - 1) * m_landScapeSize);
m_terrainGrid[i, j].treeDistance = m_treeDistance;
m_terrainGrid[i, j].treeBillboardDistance = m_treeBillboardDistance;
m_terrainGrid[i, j].treeCrossFadeLength = m_treeCrossFadeLength;
m_terrainGrid[i, j].treeMaximumFullLODCount = m_treeMaximumFullLODCount;
m_terrainGrid[i, j].detailObjectDensity = m_detailObjectDensity;
m_terrainGrid[i, j].detailObjectDistance = m_detailObjectDistance;
m_terrainGrid[i, j].GetComponent<Collider>().enabled = false;
m_terrainGrid[i, j].basemapDistance = 4000;
m_terrainGrid[i, j].castShadows = false;
PatchManager.AddTerrainInfo(curGlobalIndexX + i - 1, curGlobalIndexZ + j - 1, m_terrainGrid[i, j], m_terrainGrid[i, j].transform.position);
}
}
PatchManager.MakePatches();
int patchCount = PatchManager.patchQueue.Count;
for(int i = 0; i < patchCount; i++)
PatchManager.patchQueue.Dequeue().ExecutePatch();
UpdateIndexes();
UpdateTerrainNeighbors();
StartCoroutine(FlushTerrain());
terrainIsFlushed = true;
m_terrainGrid[curCyclicIndexX, curCyclicIndexZ].GetComponent<Collider>().enabled = false;
m_terrainGrid[curCyclicIndexX, curCyclicIndexZ].GetComponent<Collider>().enabled = true;
}
void generate()
{
width = (int)size.x;
height = (int)size.y;
length = (int)size.z;
perlinCreateArrays(rand);
for (int i = 0; i < CHUNKS * CHUNKS; i++)
{
heightMap[i] = new float[width, length];
}
int x = -(CHUNKS / 2);
int y = -(CHUNKS / 2);
for (int i = 0; i < CHUNKS * CHUNKS; i++)
{
heightMap[i] = generateVoronoi(heightMap[i], new Vector2(width - 1, length - 1), false);
}
for (int i = 0; i < CHUNKS; i++)
{
for (int j = 0; j < CHUNKS; j++)
{
whereIsTerrain[i, j] = new Vector3(x * (width - 1), 0, y * (length - 1));
heightMap[i * CHUNKS + j] = k_perlin(heightMap[i * CHUNKS + j], width, length, 0.5f, 0, x * (width - 1), y * (length - 1), false);
m_xOff += width;
m_zOff += length;
y++;
if (i != 0)
{
for (int k = 0; k < length - 1; k++)
{
heightMap[i * CHUNKS + j][0, k] = heightMap[(i - 1) * CHUNKS + j][length - 1, k];
}
}
if (j != 0)
{
for (int k = 0; k < length - 1; k++)
{
heightMap[i * CHUNKS + j][k, 0] = heightMap[i * CHUNKS + (j - 1)][k, length - 1];
}
}
}
y = -(CHUNKS / 2);
x++;
}
float[, ,] singlePoint = new float[1, 1, test.Length];
for (int row = 0; row < CHUNKS; row++)
{
for (int col = 0; col < CHUNKS; col++)
{
tData[col * CHUNKS + row] = new TerrainData();
tData[col * CHUNKS + row].heightmapResolution = width;
tData[col * CHUNKS + row].alphamapResolution = ALPHA_TILE_SIZE;
tData[col * CHUNKS + row].SetDetailResolution(ALPHA_TILE_SIZE, 16);
tData[col * CHUNKS + row].baseMapResolution = width - 1 + 1;
tData[col * CHUNKS + row].SetHeights(0, 0, heightMap[col * CHUNKS + row]);
tData[col * CHUNKS + row].size = new Vector3(width - 1, height, length - 1);
tData[col * CHUNKS + row].splatPrototypes = test;
tData[col * CHUNKS + row].detailPrototypes = setDetails(tData[col * CHUNKS + row]);
tData[col * CHUNKS + row].SetDetailLayer(0, 0, 0, getDetailLayers(tData[col * CHUNKS + row]));
TreePrototype[] _treeprotos = new TreePrototype[_treeInstance.Length];
for (int i = 0; i < _treeInstance.Length; i++)
{
_treeprotos[i] = new TreePrototype();
_treeprotos[i].prefab = _treeInstance[i];
_treeprotos[i].bendFactor = 1f;
_treeprotos[i].prefab.renderer.material.color = Color.white;
}
tData[col * CHUNKS + row].treePrototypes = _treeprotos;
for (int i = 0; i < ALPHA_TILE_SIZE; i++)
{
for (int j = 0; j < ALPHA_TILE_SIZE; j++)
{
//Texture INDEX.
//0 GoodDIrt
//1 Grass
//2 Grass&Pock
//3 Cliff
//4 snow1
//5 snow2
//6 snow3
//...end..
var CurrentHeight = heightMap[col * CHUNKS + row][i * width / ALPHA_TILE_SIZE, j * length / ALPHA_TILE_SIZE];
var blendFactor = (float)rand.NextDouble();
#region TEXTURING
if (CurrentHeight < 0.2f && CurrentHeight > 0.0f)
{
singlePoint[0, 0, 0] = blendFactor / 2f;
singlePoint[0, 0, 1] = blendFactor / 2f;
singlePoint[0, 0, 2] = 1f - blendFactor;
singlePoint[0, 0, 3] = 0f;
singlePoint[0, 0, 4] = 0f;
singlePoint[0, 0, 5] = 0f;
singlePoint[0, 0, 6] = 0f;
}
else
if (CurrentHeight < 0.3)
{
singlePoint[0, 0, 0] = 0f;
singlePoint[0, 0, 1] = 0f;
singlePoint[0, 0, 2] = 1f;
singlePoint[0, 0, 3] = 0f;
singlePoint[0, 0, 4] = 0f;
singlePoint[0, 0, 5] = 0f;
singlePoint[0, 0, 6] = 0f;
}
else
if (CurrentHeight < 0.6)
{
singlePoint[0, 0, 0] = 0f;
singlePoint[0, 0, 1] = blendFactor;
singlePoint[0, 0, 2] = 0f;
singlePoint[0, 0, 3] = 1f - blendFactor;
singlePoint[0, 0, 4] = 0f;
singlePoint[0, 0, 5] = 0f;
singlePoint[0, 0, 6] = 0f;
}
else
if (CurrentHeight < 0.8)
{
singlePoint[0, 0, 0] = 0f;
singlePoint[0, 0, 1] = 0f;
singlePoint[0, 0, 2] = 0f;
singlePoint[0, 0, 3] = 0.1f + blendFactor;
singlePoint[0, 0, 4] = 1f;
singlePoint[0, 0, 5] = 0f;
singlePoint[0, 0, 6] = 0f;
}
else
{
singlePoint[0, 0, 0] = 0f;
singlePoint[0, 0, 1] = 0f;
singlePoint[0, 0, 2] = 0f;
singlePoint[0, 0, 3] = 0f;
singlePoint[0, 0, 4] = 0f;
singlePoint[0, 0, 5] = 0f;
singlePoint[0, 0, 6] = 1f;
}
tData[col * CHUNKS + row].SetAlphamaps(j, i, singlePoint);
#endregion
}
}
terrain[row, col] = Terrain.CreateTerrainGameObject(tData[col * CHUNKS + row]);
terrain[row, col].transform.position = whereIsTerrain[row, col] - new Vector3(2.87f * row, 0, 2.87f * col);
terrain[row, col].name = (++terrno).ToString();
terrain[row, col].GetComponent<Terrain>().Flush();
terrain[row, col].GetComponent<Terrain>().terrainData.RefreshPrototypes();
}
}
}
extern internal static bool ValidateTreePrototype([NotNull] TreePrototype prototype, out string errorMessage);
private void LoadTrees(string xvalue, string yvalue, TerrainData tdata)
{
if (_trees.Count > 0)
{
System.Collections.Generic.List<TreeInstance> treelist = new System.Collections.Generic.List<TreeInstance>();
TreePrototype[] prototypes = new TreePrototype[_trees.Count];
for (int k = 0; k < _trees.Count; k++)
{
TreeMapInfo2 tree = _trees[k];
// Load splatmap file
string treefile = string.Format(tree.Filemask, xvalue, yvalue);
string[] treefiles = System.IO.Directory.GetFiles(_imagesPath, treefile + ".*");
System.Uri uri = new System.Uri(treefiles[0]);
WWW imageloader = new WWW(uri.AbsoluteUri);
treefiles = null;
while (!imageloader.isDone)
{
}
Color[] imagecolors = imageloader.texture.GetPixels();
int imagewidth = imageloader.texture.width;
imageloader.Dispose();
// Create Tree Prototype
TreePrototype tp = new TreePrototype();
tp.prefab = tree.Prefab;
tp.bendFactor = tree.BendFactor;
prototypes[k] = tp;
float treefactor = 0;
for (int u = 0; u < _heightmapsize.x; u++)
{
for (int v = 0; v < _heightmapsize.y; v++)
{
//if (imagecolors[(((imagewidth - 1) - v) * imagewidth) + u].grayscale >= 0.035)
//{
// Get treemap resolution / terrain size bias
float xbias = _terrainsize.x/imagewidth;
float ybias = _terrainsize.z/imagewidth;
// Calculate Tree Position
float terrainheight = tdata.size.y;
float terrainwidth = tdata.size.x;
Vector3 treeposition = new Vector3();
treeposition.x = (v*xbias)/terrainwidth;
treeposition.y = tdata.GetHeight(v, u)/terrainheight;
treeposition.z = (u*ybias)/terrainwidth;
TreeInstance ti = new TreeInstance();
ti.prototypeIndex = k;
ti.position = treeposition;
ti.lightmapColor = new Color(1, 1, 1);
ti.heightScale = (tree.HeightScale/100) +
UnityEngine.Random.Range(-(tree.HeightVariation/100),
(tree.HeightVariation/100));
ti.widthScale = (tree.WidthScale/100) +
UnityEngine.Random.Range(-(tree.WidthVariation/100), (tree.WidthVariation/100));
ti.color = new Color(1, 1, 1);
float treestoplace = imagecolors[((imagewidth - 1) - u)*imagewidth + v].r*tree.MaxDensity;
treefactor += treestoplace;
if (treefactor > (1.0f + UnityEngine.Random.Range(-0.2f, 0.2f)))
{
treelist.Add(ti);
treefactor = 0;
}
}
}
}
tdata.treePrototypes = prototypes;
tdata.treeInstances = treelist.ToArray();
prototypes = null;
treelist.RemoveRange(0, treelist.Count);
treelist = null;
System.GC.Collect(0);
}
}
void Start()
{
noise = new PerlinNoise ();
noise.baseOctave = noiseBaseOctave;
noise.weights = noiseWeights;
noise.Init ();
chunkResolution = (int)Math.Pow (2, chunkExponent) + 1;
chunkWidth = chunkResolution * chunkScale;
chunks = new Hashtable ();
heightmapQueue = Queue.Synchronized (new Queue ());
reverseThermalEroder = new ThermalTerrainErosion ();
reverseThermalEroder.talus = this.reverseErosionTalus;
reverseThermalEroder.strength = this.reverseErosionStrength;
reverseThermalEroder.reverse = true;
reverseThermalEroder.reverseTalusCutoff = this.reverseErosionReverseTalusCutoff;
reverseThermalEroder.iterations = this.reverseErosionIterations;
hydraulicEroder = new HydraulicTerrainErosion ();
hydraulicEroder.rainfallAmount = hydraulicErosionRainfallAmount; // kr
hydraulicEroder.evaporationRatio = hydraulicErosionEvaporationRatio; // ke
hydraulicEroder.sedimentCapacity = hydraulicErosionSedimentCapacity; // kc
hydraulicEroder.soilSolubility = hydraulicErosionSoilSolubility; // ks
hydraulicEroder.rainAltitude = hydraulicErosionRainAltitude;
hydraulicEroder.rainFalloff = hydraulicErosionRainFalloff;
hydraulicEroder.iterations = hydraulicErosionIterations;
thermalEroder = new ThermalTerrainErosion ();
thermalEroder.talus = this.thermalErosionTalus;
thermalEroder.strength = this.thermalErosionStrength;
thermalEroder.reverse = false;
thermalEroder.iterations = this.thermalErosionIterations;
texturer = new Texturer();
texturer.Init();
texturer.slopeValue = slopeValue;
texturer.mountainPeekStart = mountainPeekStart;
texturer.mountainPeekHeight = mountainPeekHeight;
texturer.waterHeight = waterHeight;
texturer.shoreHeight = shoreHeight;
splats = new SplatPrototype[diffuses.Length];
texturer.treeHeightFactor = treeHeightFactor;
texturer.treeStrength = treeStrength;
treeProto = new TreePrototype[treePrefab.Length];
for (var i = 0; i < treePrefab.Length; i++) {
treeProto[i] = new TreePrototype();
treeProto[i].bendFactor = 0;
treeProto[i].prefab = treePrefab[i];
}
grassPlacer = new GrassPlacement();
grassPlacer.grassType = grassType;
grassPlacer.texturesToAffect = texturesToAffect;
for (var i = 0; i < diffuses.Length; i++) {
splats[i] = new SplatPrototype();
splats[i].texture = diffuses[i];
splats[i].normalMap = normals[i];
splats[i].tileSize = new Vector2(5, 5);
}
grassProto = new DetailPrototype[1];
grassProto[0] = new DetailPrototype();
grassProto[0].prototypeTexture = grass;
grassProto[0].bendFactor = 0.1f;
grassProto[0].dryColor = new Color(0.804f, 0.737f, 0.102f, 1.000f);
grassProto[0].healthyColor = new Color(0.263f, 0.976f, 0.165f, 1.000f);
grassProto[0].maxHeight = 0.5f;
grassProto[0].minHeight = 0.2f;
grassProto[0].maxWidth = 1f;
grassProto[0].minWidth = 0.5f;
grassProto[0].noiseSpread = 0.1f;
grassProto[0].prototype = null;
grassProto[0].renderMode = DetailRenderMode.GrassBillboard;
grassProto[0].usePrototypeMesh = false;
ensureChunk(new ChunkCoord(0, 0), false);
ensureChunk(new ChunkCoord(-1, -1), true);
ensureChunk(new ChunkCoord(0, -1), true);
ensureChunk(new ChunkCoord(-1, 0), true);
}
void FillTreeInstances()
{
terrain.treeDistance = m_treeDistance;
terrain.treeBillboardDistance = m_treeBillboardDistance;
terrain.treeCrossFadeLength = m_treeCrossFadeLength;
terrain.treeMaximumFullLODCount = m_treeMaximumFullLODCount;
m_treeProtoTypes = new TreePrototype[2];
m_treeProtoTypes[0] = new TreePrototype();
m_treeProtoTypes [0].prefab = m_tree0;
m_treeProtoTypes [1] = new TreePrototype ();
m_treeProtoTypes[1].prefab = m_tree1;
terrain.terrainData.treePrototypes = m_treeProtoTypes;
PerlinNoise m_treeNoise = new PerlinNoise(Random.Range(0,100));
//ArrayList instances = new ArrayList();
for(int x = 0; x < m_terrainSize; x += m_treeSpacing)
{
for (int z = 0; z < m_terrainSize; z += m_treeSpacing)
{
float unit = 1.0f / (m_terrainSize - 1);
float offsetX = Random.value * unit * m_treeSpacing;
float offsetZ = Random.value * unit * m_treeSpacing;
float normX = x * unit + offsetX;
float normZ = z * unit + offsetZ;
// Get the steepness value at the normalized coordinate.
float angle = terrain.terrainData.GetSteepness(normX, normZ);
// Steepness is given as an angle, 0..90 degrees. Divide
// by 90 to get an alpha blending value in the range 0..1.
float frac = angle / 90.0f;
if(frac < 0.45f) //make sure tree are not on steep slopes
{
float worldPosX = x;
float worldPosZ = z;
float noise = m_treeNoise.FractalNoise2D(worldPosX, worldPosZ, 3, m_treeFrq, 1.0f);
float ht = terrain.terrainData.GetInterpolatedHeight(normX, normZ);
if(noise > 0.0f && ht < m_terrainHeight*0.4f)
{
TreeInstance temp = new TreeInstance();
temp.position = new Vector3(normX,ht,normZ);
temp.prototypeIndex = Random.Range (0, 2);
temp.widthScale = 1f;
temp.heightScale = 1f;
temp.color = Color.white;
temp.lightmapColor = Color.white;
terrain.AddTreeInstance(temp);
}
}
}
}
//terrain.terrainData.treeInstances = (TreeInstance[])instances.ToArray(typeof(TreeInstance));
terrain.terrainData.SetHeights(0, 0, new float[,] { { } });
terrain.Flush ();
}
TreePrototype[] treeArray; // Vector de árboles para el mapa.
#endregion Fields
#region Methods
void CreateProtoTypes()
{
//Creador de los prototypes, tanto para los splat ( texturas ) como los árboles y los adornos extra
//ZONA TEXTURAS
splatArray = new SplatPrototype[4]; // Array de texturas
//Primera textura, replicar incrementando por cada textura
splatArray[0] = new SplatPrototype();
splatArray[0].texture = Textura0;
splatArray[0].tileSize = new Vector2(pesosplat0, pesosplat0);
//Fin primera textura
splatArray[1] = new SplatPrototype();
splatArray[1].texture = Textura1;
splatArray[1].tileSize = new Vector2(pesosplat1, pesosplat1);
splatArray[2] = new SplatPrototype();
splatArray[2].texture = Textura2;
splatArray[2].tileSize = new Vector2(pesosplat2, pesosplat2);
splatArray[3] = new SplatPrototype();
splatArray[3].texture = Textura3;
splatArray[3].tileSize = new Vector2(pesosplat3, pesosplat3);
//******************************
//ZONA ÁRBOLES
treeArray = new TreePrototype[3];
treeArray[0] = new TreePrototype();
treeArray[0].prefab = Arbol1;
treeArray[1] = new TreePrototype();
treeArray[1].prefab = Arbol2;
treeArray[2] = new TreePrototype();
treeArray[2].prefab = Arbol3;
//*************************************************
//ZONA HIERBA
detailArray = new DetailPrototype[3];
detailArray[0] = new DetailPrototype();
detailArray[0].prototypeTexture = detalle1;
detailArray[0].renderMode = EstiloDeDetallado;
detailArray[0].healthyColor = color_hierba;
detailArray[0].dryColor = color_hierba2;
detailArray[1] = new DetailPrototype();
detailArray[1].prototypeTexture = detalle2;
detailArray[1].renderMode = EstiloDeDetallado;
detailArray[1].healthyColor = color_hierba;
detailArray[1].dryColor = color_hierba2;
detailArray[2] = new DetailPrototype();
detailArray[2].prototypeTexture = detalle3;
detailArray[2].renderMode = EstiloDeDetallado;
detailArray[2].healthyColor = color_hierba;
detailArray[2].dryColor = color_hierba2;
//**************************************************************
}
void CreateProtoTypes()
{
//Ive hard coded 2 splat prototypes, 3 tree prototypes and 3 detail prototypes.
//This is a little inflexible way to do it but it made the code simpler and can easly be modified
m_splatPrototypes = new SplatPrototype[2];
m_splatPrototypes[0] = new SplatPrototype();
m_splatPrototypes[0].texture = m_splat0;
m_splatPrototypes[0].tileSize = new Vector2(m_splatTileSize0, m_splatTileSize0);
m_splatPrototypes[1] = new SplatPrototype();
m_splatPrototypes[1].texture = m_splat1;
m_splatPrototypes[1].tileSize = new Vector2(m_splatTileSize1, m_splatTileSize1);
m_treeProtoTypes = new TreePrototype[3];
m_treeProtoTypes[0] = new TreePrototype();
m_treeProtoTypes[0].prefab = m_tree0;
m_treeProtoTypes[1] = new TreePrototype();
m_treeProtoTypes[1].prefab = m_tree1;
m_treeProtoTypes[2] = new TreePrototype();
m_treeProtoTypes[2].prefab = m_tree2;
m_detailProtoTypes = new DetailPrototype[3];
m_detailProtoTypes[0] = new DetailPrototype();
m_detailProtoTypes[0].prototypeTexture = m_detail0;
m_detailProtoTypes[0].renderMode = detailMode;
m_detailProtoTypes[0].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[0].dryColor = m_grassDryColor;
m_detailProtoTypes[1] = new DetailPrototype();
m_detailProtoTypes[1].prototypeTexture = m_detail1;
m_detailProtoTypes[1].renderMode = detailMode;
m_detailProtoTypes[1].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[1].dryColor = m_grassDryColor;
m_detailProtoTypes[2] = new DetailPrototype();
m_detailProtoTypes[2].prototypeTexture = m_detail2;
m_detailProtoTypes[2].renderMode = detailMode;
m_detailProtoTypes[2].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[2].dryColor = m_grassDryColor;
}
private void fillPrototypes(){
for (int i= 0; i < textures.Length ; i++) {
SplatPrototype splatPrototype = new SplatPrototype();
splatPrototype.texture = textures[i];
splatPrototype.tileSize = new Vector2 (2, 2);
texturePrototypes.Add( splatPrototype);
}
for (int i= 0; i < trees.Length ; i++) {
TreePrototype treePrototype = new TreePrototype();
treePrototype.prefab = trees[i];
treePrototypes.Add( treePrototype);
}
for (int i=0; i< details.Length; i++) {
DetailPrototype detailPrototype = new DetailPrototype();
detailPrototype.prototypeTexture = details[i];
detailPrototype.renderMode = detailMode;
detailPrototype.healthyColor = m_grassHealthyColor;
detailPrototype.dryColor = m_grassDryColor;
detailPrototypes.Add (detailPrototype);
}
}
public bool treeDataCreated()
{
int noOfTreePrefabs = treePrefabs.Length;
treePrototypes = new TreePrototype[noOfTreePrefabs];
for (int i=0; i<noOfTreePrefabs; i++) {
treePrototypes[i] = new TreePrototype();
treePrototypes[i].prefab = treePrefabs[i];
}
return true;
}
public TreePrototype(TreePrototype other)
{
prefab = other.prefab;
bendFactor = other.bendFactor;
}
/**
* Ajoute les arbres sur le Terrain.
*/
void AddTrees(){
//Check if tree is necessary
float percentage = ((float)GroundManager.NB_GRASSHILL / (float)(tData.alphamapHeight * tData.alphamapWidth));
//Debug.Log("Pourcentage texture herbe : " + percentage);
//Debug.Log("Nb textures herbes : " + GroundManager.NB_GRASSHILL);
if(percentage < season.seasons[season.CurrentSeason].trees.treeProbability){
return;
}
// Ajout des arbres au Terrain
TreePrototype[] treesProto = new TreePrototype[season.seasons[season.CurrentSeason].trees.treesGamobject.Length];
for(int i = 0 ; i < season.seasons[season.CurrentSeason].trees.treesGamobject.Length ; i++){
treesProto[i] = new TreePrototype();
treesProto[i].prefab = season.seasons[season.CurrentSeason].trees.treesGamobject[i];
}
tData.treePrototypes = treesProto;
int nbTrees = Mathf.FloorToInt((Random.Range(season.seasons[season.CurrentSeason].trees.minTree, season.seasons[season.CurrentSeason].trees.maxTree) / 100f) * GroundManager.NB_GRASSHILL);
//Debug.Log("NBTREES : " + nbTrees);
treeInstances = new TreeInstance[nbTrees];
for(int i = 0 ; i < nbTrees ; i++){
int xPos = 0;
int zPos = 0;
int index = 0;
do{
xPos = Random.Range(0, hMap.width);
zPos = Random.Range(0, hMap.height);
index++;
}while((tData.GetHeight (zPos,xPos) < season.seasons[season.CurrentSeason].textures[Texture.GRASSHILL].minHeight || tData.GetHeight (zPos,xPos) > season.seasons[season.CurrentSeason].textures[Texture.GRASSHILL].maxHeight) && index < 1000);
if(index >= 1000){
i--;
continue;
}
float yPos = tData.GetHeight (zPos,xPos);
Vector3 position = new Vector3(zPos, yPos, xPos);
position = new Vector3(position.x / hMap.width, position.y / tData.size.y, position.z / hMap.height);
treeInstances[i].position = position;
treeInstances[i].widthScale = 0;
treeInstances[i].heightScale = 0;
treeInstances[i].color = Color.white;
treeInstances[i].lightmapColor = Color.white;
treeInstances[i].prototypeIndex = Random.Range(0, season.seasons[season.CurrentSeason].trees.treesGamobject.Length);
}
tData.treeInstances = treeInstances;
StartCoroutine(GrowTrees());
}
/// <summary>
/// Prototypes are used by Unity internally.
/// This method must be called explicitly prior to generation, if any related variables changed.
/// </summary>
public void CreateProtoTypes()
{
m_splatPrototypes = new SplatPrototype[m_splatMapSettings.Length];
for (var i = 0; i < m_splatMapSettings.Length; ++i) {
m_splatPrototypes[i] = new SplatPrototype{
texture = m_splatMapSettings[i].texture,
tileSize = m_splatMapSettings[i].tileSize,
tileOffset = m_splatMapSettings[i].tileOffset
};
}
if (m_treeObjects == null) {
m_treeObjects = new GameObject[0];
}
m_treeProtoTypes = new TreePrototype[m_treeObjects.Length];
for (var i = 0; i < m_treeObjects.Length; ++i) {
m_treeProtoTypes[i] = new TreePrototype();
m_treeProtoTypes[i].prefab = m_treeObjects[i];
}
m_detailProtoTypes = new DetailPrototype[m_detailTextures.Length];
for (var i = 0; i < m_detailTextures.Length; ++i) {
m_detailProtoTypes[i] = new DetailPrototype();
m_detailProtoTypes[i].prototypeTexture = m_detailTextures[i];
m_detailProtoTypes[i].renderMode = m_detailMode;
m_detailProtoTypes[i].healthyColor = m_grassHealthyColor;
m_detailProtoTypes[i].dryColor = m_grassDryColor;
}
}
/// <summary>
/// Write the specified value using the writer.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="writer">Writer.</param>
public override void Write(object value, ISaveGameWriter writer)
{
UnityEngine.TreePrototype treePrototype = (UnityEngine.TreePrototype)value;
writer.WriteProperty("prefab", treePrototype.prefab);
writer.WriteProperty("bendFactor", treePrototype.bendFactor);
}
