public void GenerateMap()
{
Log.SetWorker("GenerateMap");
Seed.seed = testSeed;
Log.InfoSet("Seed");
BaseGeneratorSettings set = GameSettingsProvider.GetSettings <BaseGeneratorSettings>();
Watcher.WatchRun(() => WorldMesh.CreateWorldMesh(set.worldWidth, set.worldHeight, set.chunkWidth, set.chunkHeight), "CreateWorldMesh");
Watcher.WatchRun(() => WorldChunkMap.CreateMap(set.worldWidth, set.worldHeight, set.chunkWidth, set.chunkHeight, chunkObject.transform.localScale), "CreateMap");
// Voronoi > Regions > Calculate triangles
// WaterMask > SetWater > SetCoastline > Set distances
// Set rivers
// Set height > Smooth height
// Set moisture
// Draw colors > smooth colors
Log.ResetWorker();
AThread thread = new AThread(generatorGraph.GetGenerateAction());
thread.Start();
thread.RunAfterThreadEnd(() => WorldChunkMap.CreateChunks(chunkObject, transform, true));
}
public static void DrawOcean()
{
foreach (Region region in RegionsInfo.regions.Where(region => region.type.isWater && !region.type.isLake))
{
region.DoForEachPosition(pos => WorldMesh.colorMap[pos.x, pos.y].ALL = Color.white);
}
WorldMesh.ConfrimChangeSplitted();
}
public static void DrawHeight()
{
foreach (Region region in RegionsInfo.regions)
{
Color targetColor = Color.Lerp(Color.black, Color.white, (float)region.type.DistIndexFromCoastline / RegionsInfo.MaxDistIndex);
region.DoForEachPosition(pos => WorldMesh.colorMap[pos.x, pos.y].ALL = targetColor);
}
WorldMesh.ConfrimChangeSplitted();
}
public static void DrawAllWater()
{
foreach (Region region in RegionsInfo.regions)
{
Color targetColor = region.type.isWater ? Color.white : Color.black;
region.DoForEachPosition(pos => WorldMesh.colorMap[pos.x, pos.y].ALL = targetColor);
}
DrawRivers();
WorldMesh.ConfrimChangeSplitted();
}
public static void DrawRivers()
{
foreach (River river in RiversInfo.rivers)
{
foreach (Vector2Int pos in river.path)
{
// Draw lakes white
Vector2Int quadPos = WorldMesh.VertexPosToQuadPos(pos);
WorldMesh.colorMap[quadPos.x, quadPos.y].ALL = Color.white;
}
}
WorldMesh.ConfrimChangeSplitted();
}
private void Triangulate(WorldMesh mesh, TileObject tile)
{
Vector3 center = tile.transform.localPosition;
for (int i = 0; i < 6; i++)
{
mesh.AddRenderTriangle(center, center + GetCorner(i), center + GetCorner(i + 1));
mesh.AddTriangleColor(tile.color);
mesh.AddRenderTriangle(center + GetCorner(i + 1), center + GetCorner(i), center + GetCorner(i) + Vector3.down);
mesh.AddRenderTriangle(center + GetCorner(i) + Vector3.down, center + GetCorner(i + 1) + Vector3.down, center + GetCorner(i + 1));
mesh.AddTriangleColor(tile.color * 0.5f);
mesh.AddTriangleColor(tile.color * 0.5f);
}
}
public static void DrawMoisture()
{
foreach (Region region in RegionsInfo.regions)
{
Color targetColor;
if (region.type.Moisture != null)
{
targetColor = Color.Lerp(Color.black, Color.white, (float)region.type.Moisture / RegionsInfo.MaxMoistureIndex);
}
else
{
targetColor = Color.red;
}
region.DoForEachPosition(pos => WorldMesh.colorMap[pos.x, pos.y].ALL = targetColor);
}
WorldMesh.ConfrimChangeSplitted();
}
private void CenterView()
{
if (preview != null && preview.LODs.Count > 0)
{
WorldMesh m = preview.LODs[0].Mesh;
view.Camera.Position = m.AABBCenter;
view.Camera.FocusDepth = Math.Max(m.AABBHalfSize.X * 2.0f, Math.Max(m.AABBHalfSize.Y * 2.0f, m.AABBHalfSize.Z * 2.0f));
if (view.Camera.FirstPerson)
{
view.Camera.Position -= view.Camera.CameraForward * view.Camera.FocusDepth;
}
}
else
{
view.Camera.Position = SharpDX.Vector3.Zero;
view.Camera.Pitch = -(float)Math.PI / 5.0f;
view.Camera.Yaw = (float)Math.PI / 4.0f;
}
}
public void Triangulate(TileObject[] tiles)
{
WorldMesh mesh = new WorldMesh();
for (int i = 0; i < tiles.Length; i++)
{
Triangulate(mesh, tiles[i]);
if (mesh.vertices.Count + VerticesPerTile >= 65534 || i == tiles.Length - 1)
{
meshes.Add(mesh);
mesh = new WorldMesh();
}
}
for (int i = 0; i < meshes.Count; i++)
{
CreateMesh(meshes[i]);
}
}
private void CreateMesh(WorldMesh mesh)
{
mesh.mesh.vertices = mesh.vertices.ToArray();
mesh.mesh.triangles = mesh.triangles.ToArray();
mesh.mesh.colors = mesh.colors.ToArray();
mesh.mesh.RecalculateNormals();
MeshRenderer renderer = new GameObject("Mesh").AddComponent <MeshRenderer>();
renderer.transform.SetParent(transform);
renderer.sharedMaterial = material;
MeshFilter filter = renderer.gameObject.AddComponent <MeshFilter>();
filter.sharedMesh = mesh.mesh;
MeshCollider collider = renderer.gameObject.AddComponent <MeshCollider>();
collider.sharedMesh = mesh.mesh;
}
public void DrawMapInEditor()
{
textureData.ApplyToMaterial(terrainMaterial);
textureData.UpdateMeshHeights(terrainMaterial, heightMapSettings.minHeight, heightMapSettings.maximumMapHeight);
HeightMap heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, Vector2.zero);
if (drawMode == DrawMode.NoiseMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(heightMap));
}
else if (drawMode == DrawMode.Mesh)
{
DrawMesh(WorldMesh.GenerateTerrainMesh(heightMap.values, meshSettings, editorPreviewLOD));
//DrawWater();
}
else if (drawMode == DrawMode.FalloffMap)
{
DrawTexture(TextureGenerator.TextureFromHeightMap(new HeightMap(WorldFalloff.GenerateFalloffMap(meshSettings.numVertsPerLine), 0, 1, heightMapSettings.maximumMapHeight)));
}
}
public int this[int x, int y]
{
get
{
if (IsValid(x, y))
{
return(map[x, y]);
}
return(0);
}
set
{
if (IsValid(x, y))
{
map[x, y] = value;
WorldMesh.SetEditedPosition(x, y);
}
}
}
public void CreateGrid()
{
mesh = world.GetComponent <WorldMesh>();
generator = world.GetComponent <WorldGenerator>();
nodeDiameter = mesh.tileSize.x;
nodeRadius = nodeDiameter / 2.0f;
gridSizeX = generator.width;
gridSizeY = generator.height;
grid = new PathNode[gridSizeX, gridSizeY];
Vector3 worldBottomLeft = transform.position - Vector3.right * mesh.totalSize.x / 2 - Vector3.up * mesh.totalSize.y / 2;
for (int x = 0; x < gridSizeX; ++x)
{
for (int y = 0; y < gridSizeY; ++y)
{
Vector3 worldPoint = worldBottomLeft + Vector3.right * (x * nodeDiameter + nodeRadius) + Vector3.up * (y * nodeDiameter + nodeRadius);
GameWorld.Terrain terrain = world.getTerrainAtPoint(worldPoint);
grid[x, y] = new PathNode(terrain, worldPoint, x, y);
}
}
}
private void CenterView()
{
if (preview != null && preview.LODs.Count > 0)
{
WorldMesh m = preview.LODs[CurrentLOD].Mesh;
globalscale = 0.5f / m.AABBHalfSize.Length();
view.Camera.Position = m.AABBCenter * globalscale;
view.Camera.FocusDepth = 1.0f;
if (view.Camera.FirstPerson)
{
view.Camera.Position -= view.Camera.CameraForward * view.Camera.FocusDepth;
}
}
else
{
view.Camera.Position = SharpDX.Vector3.Zero;
view.Camera.Pitch = -(float)Math.PI / 5.0f;
view.Camera.Yaw = (float)Math.PI / 4.0f;
globalscale = 1.0f;
}
}
public Terrain getTerrainAtPoint(Vector2 position)
{
generator = GetComponent <WorldGenerator>();
mesh = GetComponent <WorldMesh>();
Vector2 LL = new Vector2(transform.position.x - mesh.totalSize.x / 2.0f, transform.position.y - mesh.totalSize.y / 2.0f);
Vector2 gridSpace = position - LL;
Vector2 normalized = new Vector2(gridSpace.x / mesh.totalSize.x, gridSpace.y / mesh.totalSize.y);
Vector2 tiles = new Vector2(normalized.x * generator.width, normalized.y * generator.height);
WorldTextureAtlas.Tiles tile = generator.tileMap[(int)tiles.x, (int)tiles.y];
if (tile == WorldTextureAtlas.Tiles.GrassBasic)
{
return(Terrain.Jungle);
}
else if ((int)tile >= 1 && (int)tile <= 16)
{
return(Terrain.Water);
}
else if ((int)tile == 18)
{
return(Terrain.Forest);
}
else if ((int)tile == 17)
{
return(Terrain.Mountain);
}
else if ((int)tile == 19)
{
return(Terrain.Village);
}
else if ((int)tile == 20)
{
return(Terrain.Road);
}
else
{
return(Terrain.Jungle);
}
}
public void drawMeshTest(IMesh mesh, Matrix worldMatrix)
{
var game = createGame();
var pool = createTexturePool(game);
var worldMesh = new WorldMesh {
Mesh = mesh, WorldMatrix = worldMatrix
};
var meshes = new MeshesRenderer(new RendererResourcePool(new MeshRenderDataFactory(game, null, pool), pool, game), game);
var ctx = game.Device.ImmediateContext;
var gBuffer = createGBuffer(game);
var scene = new RenderingTestsHelper.SimpleLightedScene(game, gBuffer);
var list = new List <WorldMesh>();
list.Add(worldMesh);
game.GameLoopEvent += delegate
{
ctx.ClearState();
ctx.Rasterizer.State = game.HelperStates.RasterizerShowAll;
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
meshes.DrawMeshes(list, game.Camera);
scene.Render();
};
game.Run();
}
private void SetMapHeight()
{
foreach (Triangle triangle in Triangle.allTriangles)
{
if (triangle.GetMidCLIndex() <= 0)
{
continue;
}
//Drawer.DrawConnectedLines(triangle.GetSitePositions(), Color.white);
Vector3[] trianglePoints = new Vector3[3];
for (int i = 0; i < 3; i++)
{
trianglePoints[i] = SiteWithHeight(triangle.sites[i].parent);
}
Vector2Int[] bounds = MathVert.GetBoundsBetween(triangle.GetSitePositions());
for (int i = 0; i < bounds.Length - 1; i++)
{
Vector2Int quadPos = WorldMesh.VertexPosToQuadPos(bounds[i], bounds[i + 1]);
int oriantation = WorldMesh.GetOriantation(bounds[i], bounds[i + 1]);
// WorldMesh.oriantationMap[quadPos.x, quadPos.y] = oriantation;
}
Vector2Int[] positions = MathVert.GetPositionsBetween(MathVert.GetRangesBetween(bounds));
foreach (Vector2Int position in positions)
{
//Drawer.DrawHLine(position, Color.white);
//WorldMesh.colorMap[position.x, position.y].ALL = Color.red;
Vector3 vertex = WorldMesh.verticesMap[position.x, position.y];
vertex.y = MathVert.GetHeihtBetween3Points(position, trianglePoints);
WorldMesh.verticesMap[position.x, position.y] = vertex;
}
}
}
public static void DrawColors()
{
GeneratorPart.InvokePart <ColorsPart>();
WorldMesh.ConfrimChangeSplitted();
}
private void Awake()
{
Instance = this;
}
public static void ResetHeight()
{
GeneratorPart.InvokePart <HeightPart>();
WorldMesh.ConfrimChangeSplitted();
}
private void DrawRegionColors()
{
// Draw region colors
foreach (Region region in RegionsInfo.regions)
{
BiomeColors biomeColors = colorsSettings.biomeColors[region.type.biomeType];
Vector2Int[] positions = region.GetRegionPositions();
foreach (Vector2Int pos in positions)
{
Color targetColor = Color.black;
if (region.type.isWater)
{
targetColor = biomeColors.waterColor;
}
else
{
for (int i = 0; i < colorsSettings.heightLayers.Count; i++)
{
if (WorldMesh.verticesMap[pos.x, pos.y].y <= WorldMesh.maxVertHeight * colorsSettings.heightLayers[i])
{
targetColor = biomeColors.heightColors[i];
break;
}
}
}
Vector2Int quadPos = WorldMesh.VertexPosToQuadPos(pos);
WorldMesh.colorMap[quadPos.x, quadPos.y].ALL = targetColor;
}
}
// Draw river colors
foreach (River river in RiversInfo.rivers)
{
foreach (Vector2Int pos in river.path)
{
Region region = RegionsInfo.regionsMap[pos.x, pos.y];
BiomeColors biomeColors = colorsSettings.biomeColors[region.type.biomeType];
Vector2Int quadPos = WorldMesh.VertexPosToQuadPos(pos);
WorldMesh.colorMap[quadPos.x, quadPos.y].ALL = biomeColors.waterColor;
}
}
/*foreach (Region region in RegionsInfo.regions)
* {
* Color color = Color.white;
* if (region.type.isGround) color = Color.Lerp(Color.green, color, 0.25f);
* if (region.type.isWater) color = Color.Lerp(Color.blue, color, 0.5f);
* if (region.type.isCoastline) color = Color.Lerp(Color.yellow, color, 0.8f);
* color = Color.Lerp(color, Color.black, (float)region.type.DistIndexFromCoastline / RegionsInfo.MaxDistIndex);
*
* color = Color.Lerp(Color.Lerp(Color.yellow, Color.white, 0.5f), Color.Lerp(Color.green, Color.black, 0.5f), (float)region.type.Moisture / RegionsInfo.MaxDistIndex);
* if (region.type.isWater) color = Color.Lerp(Color.blue, color, 0.3f);
* //if (region.type.isWater) color = Color.Lerp(Color.blue, Color.white, 0.3f);
*
* region.DoForEachPosition((Vector2Int point) => WorldMesh.colorMap[point.x, point.y].ALL = color);
* }
*
* foreach (Lake lake in LakesPart.lakes)
* {
* foreach (Vector2Int pathPoint in lake.path)
* {
* Vector2Int point = WorldMesh.VertexPosToQuadPos(pathPoint);
* WorldMesh.colorMap[point.x, point.y].ALL = Color.blue;
* }
* }*/
}
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings)
{
hasRequestedMesh = true;
ThreadedDataRequester.RequestData(() => WorldMesh.GenerateTerrainMesh(heightMap.values, meshSettings, lod), OnMeshDataReveiced);
}
public void drawMeshTest(IMesh mesh, Matrix worldMatrix)
{
var game = createGame();
var pool = createTexturePool(game);
var worldMesh = new WorldMesh {
Mesh = mesh, WorldMatrix = worldMatrix
};
var meshes = new MeshesRenderer(new RendererResourcePool(new MeshRenderDataFactory(game, null, pool), pool, game), game);
var ctx = game.Device.ImmediateContext;
var gBuffer = createGBuffer(game);
var scene = new RenderingTestsHelper.SimpleLightedScene(game, gBuffer);
var list = new List <WorldMesh>();
list.Add(worldMesh);
var buffer = gBuffer;
ctx = game.Device.ImmediateContext;
// Non-related init code
var point = new PointLightRenderer(game, buffer);
point.LightRadius = 3;
point.LightIntensity = 1;
point.ShadowsEnabled = false;
var angle = 0f;
var combineFinal = new CombineFinalRenderer(game, buffer);
var raster = new RasterizerStateDescription()
{
CullMode = CullMode.Front,
FillMode = FillMode.Solid
};
var state = RasterizerState.FromDescription(game.Device, raster);
point.LightRadius = 10;
game.GameLoopEvent += delegate
{
ctx.ClearState();
ctx.Rasterizer.State = state;
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
meshes.DrawMeshes(list, game.Camera);
angle += MathHelper.Pi * game.Elapsed;
var alpha = 0.99f * game.Elapsed * 20000;
var cam = game.Camera.ViewInverse.GetTranslation();
var diff = cam - point.LightPosition;
diff.Normalize();
point.LightPosition += diff * game.Elapsed * 2;// new Vector3((float)Math.Sin(angle), (float)Math.Cos(angle), -2);
ctx.ClearState();
combineFinal.SetLightAccumulationStates();
combineFinal.ClearLightAccumulation();
point.Draw();
ctx.ClearState();
game.SetBackbuffer();
ctx.Rasterizer.SetViewports(new Viewport(400, 300, 400, 300));
combineFinal.DrawCombined();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, buffer);
};
game.Run();
}
