static void RenderGizmos(TerrainSettings resizer, GizmoType gizmoType) // TODO remove this render gizmo stuff
{
Terrain terrain = resizer.GetComponent <Terrain>();
TerrainData terrainData = terrain.terrainData;
bool bAdjustPlane = EditorPrefs.GetBool(PrefName_AdjustPlane, false);
bool bAdjustHeight = EditorPrefs.GetBool(PrefName_AdjustHeight, false);
bool bShowHalfSize = EditorPrefs.GetBool(PrefName_ShowHalfSize, false);
// Border
if (bAdjustPlane || bAdjustHeight)
{
DrawBox(terrain, Vector3.zero, terrainData.size, Color.white);
}
// Half size
if (bAdjustPlane && bShowHalfSize)
{
float minX = terrainData.size.x * 0.25f;
float minZ = terrainData.size.z * 0.25f;
float maxX = terrainData.size.x - minX;
float maxZ = terrainData.size.z - minZ;
DrawBox(terrain, new Vector3(minX, 0, minZ), new Vector3(maxX, terrainData.size.y, maxZ), Color.yellow);
}
}
public NoiseGenerator(TerrainSettings _settings)
{
job = new ChunkNoiseJob();
job.frequency = _settings.frequency;
job.offset = _settings.offset;
job.noise = new Noise(_settings.seed);
}
//Create a list object of a new population that contains new indivduals defined by terrain settings
public List <TerrainSettings> createPopulation(int populationToCreate, int mapSize)
{
//Setup starting varaibles
List <TerrainSettings> population = new List <TerrainSettings>(); //Current Population
//Create a new indivdual and add it to the population for every indivdual needed as specified by the 'populationToCreate' variable
for (int x = 0; x < populationToCreate;)
{
//Setup the terrain settings object
TerrainSettings terrainSettings = new TerrainSettings();
//Set settings values
terrainSettings.Width = mapSize;
terrainSettings.Height = mapSize;
terrainSettings.Depth = randomInt(1, 50);
terrainSettings.Scale = randomFloat(0.0001f, 30.00f);
terrainSettings.Seed = randomInt(1, 10000);
terrainSettings.Octaves = randomInt(1, 10);
terrainSettings.Persistance = randomFloat(0.01f, 1.00f);
terrainSettings.Lacunarity = randomFloat(0.01f, 20.00f);
terrainSettings.OffsetX = randomFloat(0.00f, 500.00f);
terrainSettings.OffsetY = randomFloat(0.00f, 500.00f);
//Create terrain settings object
population.Add(terrainSettings);
x++;
}
return(population);
}
private static TerrainData RemoveIslandsAndPeninsulas(TerrainData data, TerrainSettings settings)
{
for (int x = 0; x < data.xSize; x++)
{
for (int z = 0; z < data.zSize; z++)
{
if (!data.IsOceanTile(x, z))
{
List <TileData> edgeAdjacentOcean = data.GetEdgeAdjacentTilesOfType(x, z, TileType.OceanFloor);
if (edgeAdjacentOcean.Count == 2)
{
Vector3 directionOne = edgeAdjacentOcean[0].Position - data.GetTileAtCoordinates(x, z).Position;
directionOne = directionOne.normalized;
Vector3 directionTwo = edgeAdjacentOcean[1].Position - data.GetTileAtCoordinates(x, z).Position;
directionTwo = directionTwo.normalized;
if (Vector3.Angle(directionOne, directionTwo) > 90)
{
Vector3 position = new Vector3(x * settings.tileSize, 0, z * settings.tileSize);
data.GetTileAtCoordinates(x, z).ReplaceTile(TileType.OceanFloor, position, Vector3.zero);
}
}
else if (edgeAdjacentOcean.Count > 2)
{
Vector3 position = new Vector3(x * settings.tileSize, 0, z * settings.tileSize);
data.GetTileAtCoordinates(x, z).ReplaceTile(TileType.OceanFloor, position, Vector3.zero);
}
}
}
}
return(data);
}
// OnInspector GUI
public override void OnInspectorGUI()
{
if (GUILayout.Button("Generate"))
{
TerrainSettings settings = GameObject.FindGameObjectWithTag("GameManager").GetComponentInChildren <TerrainSettings>();
PlaneSurface mySurface = settings.gameObject.GetComponent <PlaneSurface>();
if (mySurface == null)
{
mySurface = settings.gameObject.AddComponent <PlaneSurface>();
}
mySurface.maxHeight = (int)planeSize / 2;
mySurface.width = baseWidth;
mySurface.length = baseLength;
mySurface.planeLength = planeSize;
mySurface.tmpNodeObjects = new List <GameObject>();
mySurface.populateNodes();
mySurface.createPlanes();
Debug.Log("Terrain generated.");
}
}
protected override void OnCreate()
{
entityManager = World.Active.EntityManager;
playerSystem = World.Active.GetOrCreateSystem <PlayerEntitySystem>();
UpdateCurrentCellIndex();
previousCellIndex = new int2(100);
sectorArchetype = entityManager.CreateArchetype(
ComponentType.ReadWrite <LocalToWorld>(),
ComponentType.ReadWrite <Translation>(),
ComponentType.ReadWrite <RenderMeshProxy>()
);
float3 matrixRoot = new float3(currentCellIndex.x, 0, currentCellIndex.y);
sectorMatrix = new Matrix <Entity>(5, Allocator.Persistent, matrixRoot);
cellMatrix = new Matrix <CellMatrixItem>(5, Allocator.Persistent, matrixRoot);
EntityQueryDesc sectorSortQueryDesc = new EntityQueryDesc {
All = new ComponentType[] { typeof(AdjacentCell), typeof(SectorCell), typeof(WorleyNoise.PointData) },
None = new ComponentType[] { typeof(Tags.TerrainEntity) }
};
sectorSortQuery = GetEntityQuery(sectorSortQueryDesc);
worley = TerrainSettings.CellWorley();
topologyUtil = new TopologyUtil().Construct();
}
public TerrainSettings LoadTerrainSettings()
{
if (saveFileNameList.Count >= 1)
{
string path = Application.persistentDataPath + "/" + selectedName + ".ter";
//string path = Application.persistentDataPath + "/TerrainSettings.fun";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
TerrainSettings terrainSettings = formatter.Deserialize(stream) as TerrainSettings;
stream.Close();
return(terrainSettings);
}
else
{
Debug.LogError("(Terrain)Save file not found at: " + path);
return(null);
}
}
else
{
return(null);
}
}
public static TerrainData GenerateLandmasses(TerrainData data, TerrainSettings settings, NoiseMap noiseMap)
{
noiseMap.XRandomOffset = Random.Range(0, 10000);
noiseMap.ZRandomOffset = Random.Range(0, 10000);
for (int x = 0; x < data.xSize; x++)
{
for (int z = 0; z < data.zSize; z++)
{
Vector3 position = new Vector3(x * settings.tileSize, 0, z * settings.tileSize);
float noiseValue = noiseMap.GetLayeredPerlinValueAtPosition(x, z);
if (noiseValue < settings.oceanPercent)
{
data.GetTileAtCoordinates(x, z).ReplaceTile(TileType.OceanFloor, position, Vector3.zero);
data.GetTileAtCoordinates(x, z).elevationValue = noiseValue;
}
else if (noiseValue > settings.mountainLevel)
{
data.GetTileAtCoordinates(x, z).ReplaceTile(TileType.Mountain, position, Vector3.zero);
data.GetTileAtCoordinates(x, z).elevationValue = noiseValue;
}
else
{
data.GetTileAtCoordinates(x, z).ReplaceTile(TileType.Plains, position, Vector3.zero);
data.GetTileAtCoordinates(x, z).elevationValue = noiseValue;
}
}
}
return(data);
}
private void OnValidate()
{
if (terrainSettings == null)
{
terrainSettings = new TerrainSettings();
}
}
public CpuMeshGenerator(Action <GeneratedDataInfo <MeshData[]> > columnDataCallback, Action <GeneratedDataInfo <MeshData> > chunkDataCallback, TerrainSettings Settings)
{
this._columnDataCallback = columnDataCallback;
this._chunkDataCallback = chunkDataCallback;
this._settings = Settings;
Initialize();
}
public TerrainChunkProvider(TerrainSettings terrainSettings)
{
if (TerrainGenerator.Instance == null)
{
new TerrainGenerator(terrainSettings);
}
}
public static TerrainData GenerateBiomes(TerrainData data, TerrainSettings settings)
{
Dictionary <TileType, Vector2> biomesToClimateValues = new Dictionary <TileType, Vector2>()
{
{ TileType.Desert, settings.desert },
{ TileType.Forest, settings.forest },
{ TileType.Plains, settings.plains },
{ TileType.RainForest, settings.rainForest },
{ TileType.Taiga, settings.taiga },
{ TileType.Tundra, settings.tundra }
};
foreach (var tile in data.tiles)
{
if (!tile.type.IsWaterTile() && tile.type != TileType.Mountain)
{
Vector2 tileBiomeValue = new Vector2(tile.moistureValue, tile.temperatureValue);
TileType closestBiome = TileType.Plains;
float closestDistance = float.MaxValue;
foreach (var biome in biomesToClimateValues)
{
if (Vector2.Distance(tileBiomeValue, biome.Value) < closestDistance)
{
closestDistance = Vector2.Distance(tileBiomeValue, biome.Value);
closestBiome = biome.Key;
}
}
tile.type = closestBiome;
}
}
return(data);
}
public TerrainData(float[,] heightMap, Color[] colorMap, MeshData meshData, Vector2Int size, TerrainSettings settings)
{
this.heightMap = heightMap;
this.meshData = meshData;
this.colorMap = colorMap;
this.size = size;
this.settings = settings;
}
public TopologyUtil Construct()
{
groupSimplex = TerrainSettings.GroupSimplex();
heightSimplex = TerrainSettings.HeightSimplex();
slopeSimplex = new SimplexNoise(TerrainSettings.seed, 0.1f);
return(this);
}
public ChunkGenerator(TerrainSettings terrainSettings, Density density, ObjectPool chunkPool, List <ObjectSpawner> spawners, int maxChunksPerFrame) : base(chunkPool)
{
this.terrainSettings = terrainSettings;
this.density = density;
this.spawners = spawners;
this.maxChunksPerFrame = maxChunksPerFrame;
chunksToGenerate = new Queue <Chunk>();
}
// use when creating
public TerrainBuilder(int width, int height, int seed)
{
Seed = seed;
Width = width;
Height = height;
_presetLoader = new GradiantPresetLoader(GameServer.Instance.AppDirectory + "GradientPresets" + GameServer.sepChar);
Settings = new TerrainSettings(width, height, seed, string.Empty, string.Empty, string.Empty);
Logger.Log("Terrain initialized.");
}
// use when creating
public TerrainBuilder(int width, int height, int seed)
{
Seed = seed;
Width = width;
Height = height;
_presetLoader = new GradiantPresetLoader (GameServer.Instance.AppDirectory + "GradientPresets" + GameServer.sepChar);
Settings = new TerrainSettings (width, height, seed, string.Empty, string.Empty, string.Empty);
Logger.Log("Terrain initialized.");
}
protected override void Awake()
{
base.Awake();
terrainSettings = GetComponent <TerrainSettings>();
terrainChunkProvider = new TerrainChunkProvider(terrainSettings);
IsReadyEvent.Set();
}
public TerrainGenerator(TerrainSettings settings)
{
this.settings = settings;
noiseFilters = new INoiseFilter[settings.noiseLayers.Length];
for (int i = 0; i < noiseFilters.Length; i++)
{
noiseFilters[i] = NoiseFilterFactory.CreateNoiseFilter(settings.noiseLayers[i].noiseSettings);
}
}
public static TerrainChunk Create(Vector2 position,
TerrainSettings settings,
Transform parent,
float[,] heightMap)
{
var terrainChunk = new GameObject().AddComponent <TerrainChunk>();
terrainChunk.InitiateChunk(position, settings, parent, heightMap);
return(terrainChunk);
}
public static TerrainData GenerateTemperatureLevels(TerrainData data, TerrainSettings settings)
{
TileData equator = null;
float closestDistance = float.MaxValue;
foreach (var tile in data.tiles)
{
if (Vector3.Distance(tile.Position, settings.equatorPosition) < closestDistance)
{
equator = tile;
closestDistance = Vector3.Distance(tile.Position, settings.equatorPosition);
}
}
if (equator != null)
{
equator.temperatureValue = 1f;
bool allTilesEvaluated = false;
while (!allTilesEvaluated)
{
foreach (var tile in data.tiles)
{
if (tile.temperatureValue == 0)
{
List <TileData> adjacentTiles = data.GetAllEdgeAdjacentTiles(tile.xCoordinate, tile.zCoordinate);
float highestTempValue = 0;
for (int i = 0; i < adjacentTiles.Count; i++)
{
if (adjacentTiles[i].temperatureValue > highestTempValue)
{
highestTempValue = adjacentTiles[i].temperatureValue;
}
}
if (highestTempValue != 0)
{
tile.temperatureValue = Mathf.Clamp(highestTempValue - settings.temperatureDegradeRate, .001f, 1);
}
}
}
allTilesEvaluated = true;
foreach (var tile in data.tiles)
{
if (tile.temperatureValue == 0)
{
allTilesEvaluated = false;
break;
}
}
}
}
else
{
Debug.LogWarning("Equator = null");
}
return(data);
}
void OnSceneGUI()
{
TerrainSettings terrainResizer = (TerrainSettings)target;
Terrain terrain = terrainResizer.GetComponent <Terrain>();
// Draw bounds
Handles.color = Color.yellow;
Vector3 size = Vector3.Scale(terrain.terrainData.size, terrainResizer.transform.localScale);
Handles.DrawWireCube(terrainResizer.transform.position + size * 0.5f, size);
}
// Use this for initialization
void Awake()
{
terrainManager = ScriptableObject.CreateInstance <TerrainManager>();
terrainSettings = ScriptableObject.CreateInstance <TerrainSettings>();
if (gameMaster != this)
{
gameMaster = this;
DontDestroyOnLoad(this);
}
GameObject NewTerrain = TerrainExtensions.CreateTerrain(new Vector3(0f, 0f, 0f));
}
public void RequestTerrainData(TerrainSettings settings, Vector2 offset, Action <TerrainData> callback)
{
ThreadStart getTerrainData = delegate
{
TerrainData terrainData = GenerateTerrainData(settings, offset);
lock (callbackQueue){
callbackQueue.Enqueue(new TerrainThreadData(callback, terrainData));
}
};
new Thread(getTerrainData).Start();
}
void Start()
{
terrain = GetComponent <Terrain>();
terrainData = terrain.terrainData;
terrainSettings = GameMaster.gameMaster.terrainSettings;
gameObject.AddComponent <BoxCollider>();
coll = GetComponent <BoxCollider>();
coll.isTrigger = true;
coll.size = new Vector3(terrainSettings.MapSize.x, 200f, terrainSettings.MapSize.z);
coll.center = new Vector3(terrainSettings.MapSize.x / 2, 0f, terrainSettings.MapSize.z / 2);
}
protected override void OnCreate()
{
entityManager = World.Active.EntityManager;
playerSystem = World.Active.GetOrCreateSystem <PlayerEntitySystem>();
cellSystem = World.Active.GetOrCreateSystem <CellSystem>();
monoBehaviour = GameObject.FindObjectOfType <DebugMonoBehaviour>();
debugWorley = TerrainSettings.CellWorley();
topologyUtil = new TopologyUtil().Construct();
worleyCurrentMarker = CreateCube(float3.zero, new float4(0, 1, 0, 1));
worleyAdjacentMarker = CreateCube(float3.zero, new float4(0, 0, 1, 1));
}
// use when loading
public TerrainBuilder(TerrainSettings settings)
{
Settings = settings;
Seed = settings.seed;
Width = settings.width;
Height = settings.height;
NoiseModule = FileManager.LoadObject<IModule> (settings.moduleFile, true);
_presetLoader = new GradiantPresetLoader (GameServer.Instance.AppDirectory + "GradientPresets" + GameServer.sepChar);
GradientPreset = _presetLoader.GetPreset (settings.preset);
Gradient = GradientCreator.CreateGradientServer (new List<GradientPresets.GradientKeyData>(GradientPreset));
LoadMap (settings.imageFile);
}
// use when loading
public TerrainBuilder(TerrainSettings settings)
{
Settings = settings;
Seed = settings.seed;
Width = settings.width;
Height = settings.height;
NoiseModule = FileManager.LoadObject <IModule> (settings.moduleFile, true);
_presetLoader = new GradiantPresetLoader(GameServer.Instance.AppDirectory + "GradientPresets" + GameServer.sepChar);
GradientPreset = _presetLoader.GetPreset(settings.preset);
Gradient = GradientCreator.CreateGradientServer(new List <GradientPresets.GradientKeyData>(GradientPreset));
LoadMap(settings.imageFile);
}
public MeshJob(float[,] heightMap,
TerrainSettings settings,
int lod,
Action callback,
NativeArray <MeshData> result
)
{
_result = result;
_callback = callback;
_heightMap = heightMap;
_settings = settings;
_lod = lod;
}
public TerrainData GenerateTerrainData(TerrainSettings terrainSettings, Vector2Int size, Vector2 offset)
{
int width = size.x;
int height = size.y;
AnimationCurve heightCurve = new AnimationCurve(terrainSettings.heightCurve.keys);
float[,] heightMap = TerrainNoise.GenerateNoiseMap(width, height, terrainSettings.noiseSeed, terrainSettings.noiseScale, terrainSettings.octaves, terrainSettings.persistance, terrainSettings.lacunarity, offset, terrainSettings.normalizeMode);
Color[] colorMap = CreateColorMap(heightMap, terrainSettings.regions);
MeshData meshData = MeshGenerator.GenerateMesh(heightMap, terrainSettings.heightScale, heightCurve);
return(new TerrainData(heightMap, colorMap, meshData, size, terrainSettings));
}
// Use this for initialization
void Awake()
{
terrainSettings = ScriptableObject.CreateInstance <TerrainSettings>();
ParticleSystemSelector = ScriptableObject.CreateInstance <ScriptableParticle>();
terrainBiome = ScriptableObject.CreateInstance <TerrainBiome>();
terrainManager = ScriptableObject.CreateInstance <TerrainManager>();
if (gameMaster != this)
{
gameMaster = this;
}
DontDestroyOnLoad(this);
TerrainExtensions.CreateTerrain(new Vector3(0, 0, 0));
}
public void Setup()
{
if (Rules != null)
{
TerrainSettings s = new TerrainSettings();
s.Rules = Rules;
s.PrefabRules = PrefabRules;
s.MainMaterial = MainMaterial;
s.MainMaterialXTiling = MainMaterialXTiling;
s.MainMaterialYTiling = MainMaterialYTiling;
s.MainMaterialRotation = MainMaterialRotation;
s.TopMaterial = TopMaterial;
s.TopMaterialXTiling = TopMaterialXTiling;
s.TopMaterialYTiling = TopMaterialYTiling;
s.TopMaterialRotation = TopMaterialRotation;
s.DrawTopMeshCollider = DrawTopMeshCollider;
s.DrawTopMeshRenderer = DrawTopMeshRenderer;
s.DetailMaterial = DetailMaterial;
s.DetailMaterialXTiling = DetailMaterialXTiling;
s.DetailMaterialYTiling = DetailMaterialYTiling;
s.DetailMaterialRotation = DetailMaterialRotation;
s.DrawDetailMeshRenderer = DrawDetailMeshRenderer;
s.MainPlaneHeight = MainPlaneHeight;
s.TopPlaneHeight = TopPlaneHeight;
s.DetailPlaneHeight = DetailPlaneHeight;
s.CornerMeshWidth = CornerMeshWidth;
s.OriginalStartPoint = this.transform.position;
s.DetailPlaneOffset = new Vector3(0, .1f, -.2f);
s.MainPlaneFollowTerrainCurve = MainPlaneFollowTerrainCurve;
s.DetailPlaneFollowTerrainCurve = DetailPlaneFollowTerrainCurve;
s.ParentGameObjectName = this.name;
s.terrainDisplayer = this;
TerrainManager = new TerrainManager(s);
PrefabManager = new PrefabManager(s);
Cleanup();
}
}
public static void SetSingleShaderProperties(TerrainMeshBlend comp, TerrainSettings terrainScript)
{
GameObject activeObject = comp.gameObject;
Terrain terrain = comp.Terrain;
//activeObject.renderer.sharedMaterial.SetTexture("_Tex0", comp.SingleTerrainTexture);
Texture terrainTexture = activeObject.renderer.sharedMaterial.GetTexture("_Tex0");
for (int i = 0; i < terrain.terrainData.splatPrototypes.Length; i++)
{
if (terrain.terrainData.splatPrototypes[i].texture == terrainTexture)
{
var tileVector = activeObject.renderer.sharedMaterial.GetVector("_TileSize");
tileVector.x = terrain.terrainData.splatPrototypes[i].tileSize.x;
activeObject.renderer.sharedMaterial.SetVector("_TileSize", tileVector);
if (terrainScript != null && !comp.HasDiffuseShader())
{
switch (i)
{
case 0:
activeObject.renderer.sharedMaterial.SetTexture("_BumpMap0", terrainScript.Bump0);
break;
case 1:
activeObject.renderer.sharedMaterial.SetTexture("_BumpMap0", terrainScript.Bump1);
break;
case 2:
activeObject.renderer.sharedMaterial.SetTexture("_BumpMap0", terrainScript.Bump2);
break;
case 3:
activeObject.renderer.sharedMaterial.SetTexture("_BumpMap0", terrainScript.Bump3);
break;
default:
break;
}
}
}
}
}