// Start is called before the first frame update
void Start()
{
int mapWidth = 100;
int mapHeight = 100;
MapDisplay display = FindObjectOfType <MapDisplay>();
MapGen map = FindObjectOfType <MapGen>();
Vector2 offset = new Vector2(0, 0);
int seed = Random.Range(-1000, 1000);
float[,] noiseMap = Noise.GenerateNoiseMap(100, 100, map.noiseScale, 3, 0.2f, 3, seed, offset);
Color[] colorMap = new Color[mapWidth * mapHeight];
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
float currentHeight = noiseMap[x, y];
for (int i = 0; i < map.regions.Length; i++)
{
if (currentHeight < map.regions[i].height)
{
colorMap[(y * mapWidth) + x] = map.regions[i].color;
break;
}
}
}
}
display.DrawMesh(MeshGen.TerrainMeshGen(noiseMap, map.heightMultiplier, map.meshHeightCurve),
ColorTexture.TextureColorMap(colorMap, mapWidth, mapHeight));
}
void MeshDataThread(MapData mapData, int lod, Action <MeshData> callback)
{
MeshData meshData = MeshGen.GennerateTerrainMesh(mapData.heightMap, meshHeight, meshHeightCurve, lod);
lock (MeshDataInfoQueue)
{ MeshDataInfoQueue.Enqueue(new MapThreadInfo <MeshData>(callback, meshData)); }
}
private Mesh CreateTile(Vector3 index0, Vector3 index1, Vector3 index2, Vector3 index3)
{
MeshGen mesh = new MeshGen();
// Mesh Generation
mesh.Vertices.Add(index0);
mesh.UV.Add(new Vector2(0f, 0f));
mesh.Normals.Add(Vector3.up);
mesh.Vertices.Add(index1);
mesh.UV.Add(new Vector2(0f, 1f));
mesh.Normals.Add(Vector3.up);
mesh.Vertices.Add(index2);
mesh.UV.Add(new Vector2(1f, 1f));
mesh.Normals.Add(Vector3.up);
mesh.Vertices.Add(index3);
mesh.UV.Add(new Vector2(1f, 0f));
mesh.Normals.Add(Vector3.up);
mesh.CreateTriangles(new Vector3Int(0, 1, 2));
mesh.CreateTriangles(new Vector3Int(0, 2, 3));
mesh.ApplyMeshChanges();
return(mesh.Mesh);
}
public void UpdateMapInEditor()
{
MapData mapData = Generator();
MapDisplay display = FindObjectOfType <MapDisplay>();
if (mode == DrawMode.Biome)
{
display.DisplayTexture(TextureGen.FromBiome(mapData.colorMap, mapSize, mapSize));
}
else if (mode == DrawMode.Noise)
{
display.DisplayTexture(TextureGen.FromNoiseScale(mapData.noiseMap));
}
else if (mode == DrawMode.Mesh)
{
MeshData meshData = MeshGen.TerrainMesh(mapData.noiseMap, heightMultiplier, HeightGradiant, LevelOfDetail);
display.DisplayMesh(meshData, TextureGen.FromBiome(mapData.colorMap, mapSize, mapSize));
if (addvegetation)
{
List <GameObject> spawnedVeget = new List <GameObject>();
spawnedVeget = VegetationGenerator.PlaceVegetation(mapData.noiseMap, meshData, LevelOfDetail, biomes, density, spawnedVeget);
spawnedVeget = RaycastSpawning.Adjust(spawnedVeget, InGround);
spawnedVeget.Clear();
}
}
}
private IKBone CreateBone(float thickness, float length, Color color)
{
var bone = new IKBone(length, null);
var p = Program.Inst;
var g = p.GraphicsDevice;
var mesh = MeshGen.Disc(thickness, length + 0.05f)
.Translate(0.5f * length * Vector3.Up)
.Color(color);
p.Scene.AddEntity(new EcsEntity(new CMesh {
Mesh = mesh.Gpu(g)
},
new CIKBone {
Bone = bone
},
new CPos {
},
// new CVel { },
new CRot {
},
new CShadow {
}
));
return(bone);
}
public void MeshDataThread(MapData mapData, Action <MeshData> callback, int LOD)
{
MeshData meshData = MeshGen.GenerateTerrainMesh(mapData.heightMap, heightCoefficient, heightExponent, meshHeightCurve, LOD);
lock (meshData)
{
meshDataThreadInfoQueue.Enqueue(new MapThreadInfo <MeshData>(callback, meshData));
}
}
public void MeshRegenerated()
{
plane = GetComponent <MeshGen>();
plane.mesh.MarkDynamic();
OGverts = plane.mesh.vertices.ToList();
modVerts = plane.mesh.vertices.ToList();
Debug.Log("oh, i generated a mesh. great.");
}
void MeshDataThread(MapData mapData, Action <MeshData> callBack)
{
MeshData meshData = MeshGen.GenTerrain(mapData.heightMap, meshHeightMultipler, meshHeightCurve, levelOfDetail);
lock (meshThreadInfoQueue)
{
meshThreadInfoQueue.Enqueue(new MapThreadInfo <MeshData>(callBack, meshData));
}
}
void MeshDataThread(MapData mapData, int lod, Action <MeshData> callback)
{
MeshData meshData = MeshGen.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, lod, useFlatShading);
lock (meshDataThreadInfoQueue)
{
meshDataThreadInfoQueue.Enqueue(new MapThreadInfo <MeshData>(callback, meshData));
}
}
void MeshDataThread(MapData mapData, int lod, Action <MeshData> callback)
{
MeshData meshData = MeshGen.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, lod);
//Prevent other threads from executing this code at once
lock (meshDataThreadInfoQueue){
meshDataThreadInfoQueue.Enqueue(new MapThreadInfo <MeshData>(callback, meshData));
}
}
private void Start()
{
Map map = FindObjectOfType <Map>();
MapData mapdata = GenThatMapData(Vector2.zero);
if (drawMode == DrawMode.DrawMesh)
{
map.DrawMesh(MeshGen.GennerateTerrainMesh(mapdata.heightMap, meshHeight, meshHeightCurve, editorlevelOfDetail), TextureGen.TextureFromColorMap(mapdata.colorMap, mapChunkSize, mapChunkSize));
}
}
void Start()
{
meshG = GameObject.Find("Manager").GetComponent <MeshGen>();
cam1 = transform.GetChild(0).GetComponent <Camera>();
cam2 = transform.GetChild(1).GetComponent <Camera>();
cam1.transform.localPosition = new Vector3(0, meshG.size * 0.5f, -meshG.size);
cam2.transform.localPosition = new Vector3(0, meshG.size * 0.5f, -meshG.size);
lighthouse.transform.position = (Vector3.up - Vector3.one) * (meshG.size * 0.3f);
}
private void Start()
{
mg = new MeshGen(Materials);
mg.SetTarget(gameObject);
tempIndices = new PoolRing <List <int> >(4);
if (AutoGenerate)
{
Generate(Seed);
}
}
private void SpawnBall()
{
if (sBallMeshes == null)
{
var cols = new [] {
new Color(0.2f, 0.6f, 1.0f),
Color.OrangeRed,
};
var ballMeshes = new List <GpuMesh>();
for (var i = 0; i < cols.Length; i++)
{
var g = Program.Inst.GraphicsDevice;
var m = MeshGen.Sphere(0.1f).Color(cols[i % cols.Length]);
ballMeshes.Add(m.Gpu(g));
sBallAabb = m.Aabb();
}
sBallMeshes = ballMeshes.ToArray();
}
var rnd = new Random();
var vx = -3.0f - (float)rnd.NextDouble() * 1.0f;
var vy = (float)rnd.NextDouble() - 1.4f;
var vz = ((float)rnd.NextDouble() - 0.5f) * 0.5f;
var num = rnd.Next(sBallMeshes.Length);
Program.Inst.Scene.AddEntity(new EcsEntity(
new CMesh {
Mesh = sBallMeshes[num]
},
new CAabb {
Aabb = sBallAabb
},
new CBall {
Radius = 0.1f
},
new CVel {
Vel = new Vector3(vx, vy, vz)
},
new CShadow {
},
new CSort {
SortVal = 1 - num
},
new CPos {
Pos = new Vector3(4.8f, 0.7f, -1.0f)
}));
}
void GenerateMap()
{
map = new int[width, height];
RandomFillMap();
for (int i = 0; i < 16; i++)
{
//SmoothMap();
}
MeshGen meshGen = GetComponent <MeshGen>();
meshGen.GenerateMesh(map, 1);
}
// void ShowPath(Vector3[] points){
//
// //Debug.Log(Input.mousePosition);
// //HexCell target = HexGrid.instance.GetCell(assist.WorldToGrid(point));
// //HexCell start = HexGrid.instance.GetCell(player.transform.position);
// //Debug.Log("Clicked "+ target.q+":"+target.r);
// foreach (var item in markers) {
// Destroy(item);
// }
// markers = new GameObject[points.Length];
// for (int i = 0; i < points.Length; i++) {
//
// markers[i] = SlapMarker(points[i]);
// markers[i].name = "Hex mark";
//
// }
//
//
// //temp = waypoints[pathcount]-player.transform.position;
// //tween =
// }
GameObject SlapMarker(Vector3 pos)
{
GameObject go = new GameObject("hex");
MeshFilter mf = go.AddComponent <MeshFilter>();
go.AddComponent <MeshRenderer>();
mf.mesh = MeshGen.Hex(HexLayout.instance.wide_width);
go.transform.localScale = Vector3.one * 0.3f;
go.transform.position = pos;
go.transform.parent = field;
go.transform.localRotation = Quaternion.identity;
go.transform.localPosition += Vector3.up * 0.02f;
return(go);
}
public void PreGenerate()
{
lock (meshes)
{
for (int i = 0; i < meshes.Length; i++)
{
meshes[i].LevelOfDetail = ChunkAttributes.levelsOfDetail[i].LoD;
meshes[i].meshInfo = new MeshInfo(MeshGen.vertices(ChunkAttributes.size,
noiseMap,
meshes[i].LevelOfDetail,
Mathf.RoundToInt(ChunkAttributes.scale),
ChunkAttributes.animationCurve),
MeshGen.quadsTriangles(ChunkAttributes.size, meshes[i].LevelOfDetail),
MeshGen.uvs(ChunkAttributes.size, meshes[i].LevelOfDetail));
}
}
}
public void DrawMapInEditor()
{
MapData map = GenerateMapData(Vector2.zero);
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGen.TextureFromNoiseMap(map.heightMap));
}
else if (drawMode == DrawMode.ColourMap)
{
display.DrawTexture(TextureGen.TextureFromColourMap(map.colMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGen.GenerateTerrainMesh(map.heightMap, heightCoefficient, heightExponent, meshHeightCurve, editorLOD), TextureGen.TextureFromColourMap(map.colMap, mapChunkSize, mapChunkSize));
}
}
private void OnValidate()
{
Species.ClampValues();
if (AutoGenerate)
{
if (mg == null)
{
mg = new MeshGen(Materials);
mg.SetTarget(gameObject);
tempIndices = new PoolRing <List <int> >(4);
}
Generate(Seed);
}
}
private void UnloadStaticAssets()
{
if (!LoadedStatic)
{
// Projectiles...
ProjectileData.UnloadAll();
TempEffect.UnloadAll();
Item.UnloadAll();
MeshGen.ClearCache();
TileData.UnloadAll();
// Resources cleanup...
Resources.UnloadUnusedAssets();
LoadedStatic = false;
}
}
public void DrawMapInEditor()
{
MapData mapData = GenerateMapData(Vector2.zero);
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGen.TextureFromHeightMap(mapData.heightMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(TextureGen.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGen.GenerateMesh(mapData.heightMap, meshHeightMultiplier, meshHeightCurve, editorPreviewLOD), TextureGen.TextureFromColorMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
}
public TerrainChunk(Vector2 coord, int size, Transform parent, int layer)
{
position = coord * size;
bounds = new Bounds(position, Vector2.one * size);
Vector3 positionV3 = new Vector3(position.x, 0, position.y);
meshObject = new GameObject("TerrainChunk");
meshObject.layer = layer;
MeshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshObject.transform.position = positionV3;
meshObject.transform.SetParent(parent);
meshObject.tag = "Ground";
SetVisible(true);
MeshMatData data = chunks.mapGen.GetGeneratedData(position, coord);
meshFilter.mesh = MeshGen.GenerateTerrainMesh(data.map, 0).CreateMesh();
MeshRenderer.material = data.mat;
meshObject.AddComponent <MeshCollider>();
}
void Awake()
{
_ShadowDummyMesh = MeshGen.CreatePlane(new Vector3(0.0f, 0.0f, 1.0f), new Vector3(1.0f, 0.0f, 0.0f), _UVRect,
new Color(_ShadowColor.r, _ShadowColor.g, _ShadowColor.b, _ShadowOpacity), this);
Transform parent = transform;
_ShadowDummy = new GameObject("shadowDummy").AddComponent <ProjectorShadowDummy>();
_ShadowDummy.transform.parent = parent;
_ShadowDummy.transform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
_ShadowDummy.transform.localRotation = Quaternion.identity * parent.localRotation;
_ShadowDummy.gameObject.layer = LayerMask.NameToLayer(GlobalProjectorManager.GlobalProjectorLayer);
_ShadowDummy._ShadowLocalOffset = _ShadowLocalOffset;
_ShadowDummy._RotationAngleOffset = _RotationAngleOffset;
_ShadowDummy._freezeXRot = _FreezeXRot;
_ShadowDummy._freezeYRot = _FreezeYRot;
_ShadowDummy._freezeZRot = _FreezeZRot;
OnShadowSizeChanged();
_Renderer = _ShadowDummy.gameObject.AddComponent <MeshRenderer>();
_Renderer.receiveShadows = false;
#if UNITY_5_1 || UNITY_5_2 || UNITY_5_3 || UNITY_5_4 || UNITY_5_5 || UNITY_5_6 || UNITY_5_7 || UNITY_2017 || UNITY_2018 || UNITY_2019 || UNITY_2020
_Renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
#else
_Renderer.castShadows = false;
#endif
_Renderer.material = _Material;
_Renderer.enabled = false;
_MeshFilter = _ShadowDummy.gameObject.AddComponent <MeshFilter>();
_MeshFilter.mesh = _ShadowDummyMesh;
_initialSize = _ShadowSize;
_initialOpacity = _ShadowOpacity;
_discarded = false;
}
public void DrawingInEditor()
{
MapData mapData = GenMapData();
//referenceing MapDisplay & TextureGen for noise and color with width & height
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGen.TextureFromHeight(mapData.heightMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(TextureGen.TextureFromMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGen.GenTerrain(mapData.heightMap, meshHeightMultipler, meshHeightCurve, levelOfDetail),
TextureGen.TextureFromMap(mapData.colorMap, mapChunkSize, mapChunkSize));
}
}
// generates map using seed
public void GenerateMap()
{
currentBiome = Biome.forest;
currentRooms = new List <Room>();
roomCoordinates = new List <List <Coord> >();
hallCoordinates = new List <List <Coord> >();
// GetComponent<Renderer>().material = walls;
map = new int[currentBiome.width, currentBiome.height];
RandomFillMap();
for (int i = 0; i < currentBiome.smoothingIterations; i++)
{
SmoothMap();
}
ProcessMap();
int borderSize = 15; // sets border THICCness
int[,] borderedMap = new int[currentBiome.width + borderSize * 2, currentBiome.height + borderSize * 2];
for (int x = 0; x < borderedMap.GetLength(0); x++)
{
for (int y = 0; y < borderedMap.GetLength(1); y++)
{
if (x >= borderSize && x < currentBiome.width + borderSize && y >= borderSize && y < currentBiome.height + borderSize)
{
borderedMap[x, y] = map[x - borderSize, y - borderSize];
}
else
{
borderedMap[x, y] = 1;
}
}
}
MeshGen meshGen = GetComponent <MeshGen>();
meshGen.GenerateMesh(borderedMap, 1);
}
void GenerateMap()
{
map = new int[width, height];
RandomFillMap();
for (int i = 0; i < smoothingIterations; i++)
{
SmoothMap();
}
ProcessMap();
int borderSize = 5; // sets border THICCness
int[,] borderedMap = new int[width + borderSize * 2, height + borderSize * 2];
for (int x = 0; x < borderedMap.GetLength(0); x++)
{
for (int y = 0; y < borderedMap.GetLength(1); y++)
{
if (x >= borderSize && x < width + borderSize && y >= borderSize && y < height + borderSize)
{
borderedMap[x, y] = map[x - borderSize, y - borderSize];
}
else
{
borderedMap[x, y] = 1;
}
}
}
//GenerateMapObjects(hazards, hazardParent, true);
GenerateMapObjects(pickUps, pickupParent);
PlacePlayer();
MeshGen meshGen = GetComponent <MeshGen>();
meshGen.GenerateMesh(borderedMap, 1);
}
public void DrawMapInEditor()
{
MapData mapdata = GenThatMapData(Vector2.zero);
Map map = FindObjectOfType <Map>();
if (drawMode == DrawMode.NoiseMap)
{
map.DrawTexture(TextureGen.TextureFromHeightMap(mapdata.heightMap));
}
else if (drawMode == DrawMode.ColorMap)
{
map.DrawTexture(TextureGen.TextureFromColorMap(mapdata.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.DrawMesh)
{
map.DrawMesh(MeshGen.GennerateTerrainMesh(mapdata.heightMap, meshHeight, meshHeightCurve, editorlevelOfDetail), TextureGen.TextureFromColorMap(mapdata.colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.FallOffMap)
{
map.DrawTexture(TextureGen.TextureFromHeightMap(FalloffMapGenerator.GenerateFalloffMapp(mapChunkSize)));
}
}
private void Start()
{
_meshMaterial = new Material(Shader.Find("Standard"));
_minHeight = float.MaxValue;
_maxHeight = float.MinValue;
_prevSeed = randomSeed;
CreateChunks();
Random.InitState(randomSeed);
CreateOctaveOffsets(NumOctaves);
// Generate height maps
var heights = new float[numChunksX * numChunksY][, ];
for (var i = 0; i < numChunksY; i++)
{
for (var j = 0; j < numChunksX; j++)
{
_chunks[i * numChunksY + j].transform.position =
new Vector3(j * (chunkWidth - 1), 0, i * (chunkLength - 1));
heights[i * numChunksY + j] =
GenerateHeightMap(chunkLength, chunkWidth, i * (chunkWidth - 1), j * (chunkLength - 1));
}
}
NormaliseHeightMaps(heights);
// Create Meshes and Textures
_meshTextures = new Texture2D[numChunksX * numChunksY];
for (var i = 0; i < numChunksX * numChunksY; i++)
{
var meshData = MeshGen.GenerateTerrainMesh(heights[i], heightScale);
_meshTextures[i] = TextureFromHeightMap(heights[i]);
DrawMeshes(meshData, _meshTextures[i], i);
}
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
GenerateMap();
}
if (Input.GetKeyDown(KeyCode.Space))
{
SmoothMap(4, 5);
Debug.Log("Smoothening");
MeshGen meshGen = GetComponent <MeshGen>();
meshGen.GenerateMesh(map, 1);
}
if (Input.GetMouseButton(1))
{
SmoothMap();
Debug.Log("Smoothening");
MeshGen meshGen = GetComponent <MeshGen>();
meshGen.GenerateMesh(map, 1);
}
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoiseMap(mapWidth, mapHeight, noiseScale, octaves,
persistence, lacunarity, seed, offset);
Color[] colorMap = new Color[mapWidth * mapHeight];
for (int y = 0; y < mapHeight; y++)
{
for (int x = 0; x < mapWidth; x++)
{
float currentHeight = noiseMap[x, y];
for (int i = 0; i < regions.Length; i++)
{
if (currentHeight < regions[i].height)
{
colorMap[(y * mapWidth) + x] = regions[i].color;
break;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(ColorTexture.TextureHeightMap(noiseMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(ColorTexture.TextureColorMap(colorMap, mapWidth, mapHeight));
}
else if (drawMode == DrawMode.Mesh)
{
display.DrawMesh(MeshGen.TerrainMeshGen(noiseMap, heightMultiplier, meshHeightCurve),
ColorTexture.TextureColorMap(colorMap, mapWidth, mapHeight));
}
}
