PG/inz-00
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

zintegrowano kod Piotra

Browse Source
This commit is contained in:
Kacper Donat 2019-11-10 20:23:07 +01:00
parent cfc5bf47cf
commit e7f759acc5
14 changed files with 1982 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Assets/Editor/CaveGeneratorUI.cs Normal file
View File

@ -0,0 +1,22 @@
using Assets;
using UnityEditor;
using UnityEngine;
namespace Editor
{
[CustomEditor(typeof (CaveGenerator))]
public class CaveGeneratorUI : UnityEditor.Editor
{
public override void OnInspectorGUI()
{
var target = this.target as CaveGenerator;
DrawDefaultInspector();
if (GUILayout.Button("Generate"))
{
target.GenerateMap();
}
}
}
}

3
Assets/Editor/CaveGeneratorUI.cs.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c73a3ec370154e80987a0a5386863396
timeCreated: 1573413529

77
Assets/Materials/Cave.mat Normal file
View File

@ -0,0 +1,77 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!21 &2100000
Material:
serializedVersion: 6
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name: Cave
m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
m_ShaderKeywords:
m_LightmapFlags: 4
m_EnableInstancingVariants: 0
m_DoubleSidedGI: 0
m_CustomRenderQueue: -1
stringTagMap: {}
disabledShaderPasses: []
m_SavedProperties:
serializedVersion: 3
m_TexEnvs:
- _BumpMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailAlbedoMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailMask:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailNormalMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _EmissionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _MainTex:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _MetallicGlossMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _OcclusionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _ParallaxMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
m_Floats:
- _BumpScale: 1
- _Cutoff: 0.5
- _DetailNormalMapScale: 1
- _DstBlend: 0
- _GlossMapScale: 1
- _Glossiness: 0.5
- _GlossyReflections: 1
- _Metallic: 0
- _Mode: 0
- _OcclusionStrength: 1
- _Parallax: 0.02
- _SmoothnessTextureChannel: 0
- _SpecularHighlights: 1
- _SrcBlend: 1
- _UVSec: 0
- _ZWrite: 1
m_Colors:
- _Color: {r: 0, g: 0, b: 0, a: 1}
- _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

8
Assets/Materials/Cave.mat.meta Normal file
View File

@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 39547f644eea59f42ab142efa95176d5
NativeFormatImporter:
externalObjects: {}
mainObjectFileID: 2100000
userData:
assetBundleName:
assetBundleVariant:

77
Assets/Materials/Walls.mat Normal file
View File

@ -0,0 +1,77 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!21 &2100000
Material:
serializedVersion: 6
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_Name: Walls
m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
m_ShaderKeywords:
m_LightmapFlags: 4
m_EnableInstancingVariants: 0
m_DoubleSidedGI: 0
m_CustomRenderQueue: -1
stringTagMap: {}
disabledShaderPasses: []
m_SavedProperties:
serializedVersion: 3
m_TexEnvs:
- _BumpMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailAlbedoMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailMask:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailNormalMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _EmissionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _MainTex:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _MetallicGlossMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _OcclusionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _ParallaxMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
m_Floats:
- _BumpScale: 1
- _Cutoff: 0.5
- _DetailNormalMapScale: 1
- _DstBlend: 0
- _GlossMapScale: 1
- _Glossiness: 0.5
- _GlossyReflections: 1
- _Metallic: 0
- _Mode: 0
- _OcclusionStrength: 1
- _Parallax: 0.02
- _SmoothnessTextureChannel: 0
- _SpecularHighlights: 1
- _SrcBlend: 1
- _UVSec: 0
- _ZWrite: 1
m_Colors:
- _Color: {r: 0.46226418, g: 0.44700074, b: 0.44700074, a: 1}
- _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

8
Assets/Materials/Walls.mat.meta Normal file
View File

@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 2fc02ee6e70642f438d383c851a2b50b
NativeFormatImporter:
externalObjects: {}
mainObjectFileID: 0
userData:
assetBundleName:
assetBundleVariant:

724
Assets/Scenes/CaveGenerator.unity Normal file
View File

File diff suppressed because one or more lines are too long

7
Assets/Scenes/CaveGenerator.unity.meta Normal file
View File

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 87838c5ff83b0ae16b7364ecad285d6c
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

28
Assets/Scenes/OverworldExample.unity
View File

@ -144,7 +144,7 @@ MonoBehaviour:
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 319467306}
m_Enabled: 0
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 06dfaa94f8713f12fbe207b61b694c90, type: 3}
m_Name:
@ -153,18 +153,30 @@ MonoBehaviour:
enabled: 1
displayPoints: 1
displayBoundary: 1
displayVertices: 1
displayVertices: 0
displayNeighbours: 0
displayLabels: 0
displayEdges: 1
displayLocations: 1
displayLocationCells: 1
displayEdges: 0
displayLocations: 0
displayLocationCells: 0
displayLocationEdges: 1
displayLocationPoints: 1
displayLocationPoints: 0
size: {x: 100, y: 100}
types: []
types:
- name:
color: {r: 1, g: 0, b: 0.74144936, a: 1}
height: 0
- name:
color: {r: 0, g: 1, b: 0.94361734, a: 1}
height: 0
- name:
color: {r: 1, g: 0.008301804, b: 0, a: 1}
height: 0
- name:
color: {r: 0, g: 1, b: 0.042674065, a: 1}
height: 0
radius: 4
seed: 2040725760
seed: 1294302848
--- !u!4 &319467308
Transform:
m_ObjectHideFlags: 0

3
Assets/Scripts/Underground.meta Normal file
View File

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 5f82d33259db4b7eb88179cc01f9d9ef
timeCreated: 1573413119

602
Assets/Scripts/Underground/CaveGenerator.cs Normal file
View File

@ -0,0 +1,602 @@
using System.Collections;
using System.Collections.Generic;
using System;
using UnityEngine;
public class CaveGenerator : MonoBehaviour
{
public int width;
public int height;
public int smoothnes;
public bool cave;
public string seed;
public bool useRandomSeed;
System.Random generator;
[Range(1, 100)]
public int randomFillPercent;
int[,] map;
void Start()
{
if (useRandomSeed)
{
seed = Time.realtimeSinceStartup.ToString();
}
GenerateMap();
}
void Update()
{
if (Input.GetMouseButtonDown(0))
{
GenerateMap();
}
}
public void GenerateMap()
{
generator = new System.Random(seed.GetHashCode());
map = new int[width, height];
FillMap();
for (int i = 0; i < smoothnes; ++i)
{
SmoothMap();
}
ProcessMap();
int borderSize = 5;
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;
}
}
}
CaveMeshGenerator meshGen = GetComponent<CaveMeshGenerator>();
meshGen.GenerateMesh(borderedMap, 1);
}
//void OnDrawGizmos() {
// if (map != null) {
// for (int x = 0; x < width; x ++) {
// for (int y = 0; y < height; y ++) {
// Gizmos.color = (map[x,y] == 1)?Color.black:Color.white;
// Vector3 pos = new Vector3(-width/2 + x + .5f,0, -height/2 + y+.5f);
// Gizmos.DrawCube(pos,Vector3.one);
// }
// }
// }
//}
void ProcessMap()
{
List<List<Coord>> wallRegions = GetRegions(1);
int wallThresholdSize = 30;
List<Room> survivingRooms = new List<Room>();
foreach (List<Coord> wallRegion in wallRegions)
{
if (wallRegion.Count < wallThresholdSize)
{
foreach (Coord tile in wallRegion)
{
map[tile.tileX, tile.tileY] = 0;
}
}
}
List<List<Coord>> roomRegions = GetRegions(0);
int roomThresholdSize = 30;
foreach (List<Coord> roomRegion in roomRegions)
{
if (roomRegion.Count < roomThresholdSize)
{
foreach (Coord tile in roomRegion)
{
map[tile.tileX, tile.tileY] = 1;
}
}
else
{
survivingRooms.Add(new Room(roomRegion, map));
}
}
survivingRooms.Sort();
survivingRooms[0].m_IsMainRoom = survivingRooms[0].m_IsAccessibleFromMainRoom = true;
ConnectClosestRooms(survivingRooms);
}
void ConnectClosestRooms(List<Room> allRooms, bool forceAccessibleFromMainRoom = false)
{
List<Room> roomListA = new List<Room>();
List<Room> roomListB = new List<Room>();
if (forceAccessibleFromMainRoom)
{
foreach (Room room in allRooms)
{
if (room.m_IsAccessibleFromMainRoom)
{
roomListB.Add(room);
}
else
{
roomListA.Add(room);
}
}
}
else
{
roomListA = allRooms;
roomListB = allRooms;
}
int bestDistance = 0;
Coord bestTileA = new Coord();
Coord bestTileB = new Coord();
Room bestRoomA = new Room();
Room bestRoomB = new Room();
bool possibleConnectionFound = false;
foreach (Room roomA in roomListA)
{
if (!forceAccessibleFromMainRoom)
{
possibleConnectionFound = false;
if (roomA.m_ConnectedRooms.Count > 0)
{
continue;
}
}
foreach (Room roomB in roomListB)
{
if (roomA == roomB || roomA.IsConnected(roomB))
{
continue;
}
for (int tileIndexA = 0; tileIndexA < roomA.m_EdgeTiles.Count; ++tileIndexA)
{
for (int tileIndexB = 0; tileIndexB < roomB.m_EdgeTiles.Count; ++tileIndexB)
{
Coord tileA = roomA.m_EdgeTiles[tileIndexA];
Coord tileB = roomB.m_EdgeTiles[tileIndexB];
int distanceBetweenRooms = (int)(Mathf.Pow(tileA.tileX - tileB.tileX, 2) + Mathf.Pow(tileA.tileY - tileB.tileY, 2));
if (distanceBetweenRooms < bestDistance || !possibleConnectionFound)
{
bestDistance = distanceBetweenRooms;
possibleConnectionFound = true;
bestTileA = tileA;
bestTileB = tileB;
bestRoomA = roomA;
bestRoomB = roomB;
}
}
}
}
if (possibleConnectionFound && !forceAccessibleFromMainRoom)
{
CreatePassage(bestRoomA, bestRoomB, bestTileA, bestTileB);
}
}
if (forceAccessibleFromMainRoom && possibleConnectionFound)
{
CreatePassage(bestRoomA, bestRoomB, bestTileA, bestTileB);
ConnectClosestRooms(allRooms, true);
}
if (!forceAccessibleFromMainRoom)
{
ConnectClosestRooms(allRooms, true);
}
}
void CreatePassage(Room roomA, Room roomB, Coord tileA, Coord tileB)
{
Room.ConnectRooms(roomA, roomB);
if (cave)
{
List<Coord> line = GetLine(tileA, tileB);
foreach (Coord c in line)
{
DrawCircle(c, 4);
}
}
else
{
if (tileA.tileX < tileB.tileX)
{
for (int x = tileA.tileX; x < tileB.tileX; ++x)
{
DrawSquare(new Coord(x, tileA.tileY), 1);
}
}
else
{
for (int x = tileB.tileX; x < tileA.tileX; ++x)
{
DrawSquare(new Coord(x, tileA.tileY), 1);
}
}
if (tileA.tileY < tileB.tileY)
{
for (int y = tileA.tileY; y < tileB.tileY; ++y)
{
DrawSquare(new Coord(tileB.tileX, y), 1);
}
}
else
{
for (int y = tileB.tileY; y < tileA.tileY; ++y)
{
DrawSquare(new Coord(tileB.tileX, y), 1);
}
}
}
}
void DrawSquare(Coord c, int d)
{
for (int x = -d; x <= d; ++x)
{
for (int y = -d; y <= d; ++y)
{
int drawX = c.tileX + x;
int drawY = c.tileY + y;
if (CheckIfInMapBounds(drawX, drawY))
{
map[drawX, drawY] = 0;
}
}
}
}
void DrawCircle(Coord c, int r)
{
for(int x = -r; x <= r; ++x)
{
for (int y = -r; y <= r; ++y)
{
if (x * x + y * y <= r * r)
{
int drawX = c.tileX + x;
int drawY = c.tileY + y;
if (CheckIfInMapBounds(drawX, drawY))
{
map[drawX, drawY] = 0;
}
}
}
}
}
List<Coord> GetLine(Coord from, Coord to)
{
List<Coord> line = new List<Coord>();
int x = from.tileX;
int y = from.tileY;
int dx = to.tileX - x;
int dy = to.tileY - y;
bool inverted = false;
int step = Math.Sign(dx);
int gradientStep = Math.Sign(dy);
int longest = Math.Abs(dx);
int shortest = Math.Abs(dy);
if (longest < shortest)
{
inverted = true;
longest = Math.Abs(dy);
shortest = Math.Abs(dx);
step = Math.Sign(dy);
gradientStep = Math.Sign(dx);
}
int gradientAccumulation = longest / 2;
for (int i = 0; i < longest; ++i)
{
line.Add(new Coord(x, y));
if (inverted)
{
y += step;
}
else
{
x += step;
}
gradientAccumulation += shortest;
if (gradientAccumulation >= longest)
{
if (inverted)
{
x += gradientStep;
}
else
{
y += gradientStep;
}
gradientAccumulation -= longest;
}
}
return line;
}
Vector3 CoordToWorldPoint(Coord tile)
{
return new Vector3(-width / 2 + .5f + tile.tileX, 2, -height / 2 + .5f + tile.tileY);
}
List<List<Coord>> GetRegions(int tileType)
{
List<List<Coord>> regions = new List<List<Coord>>();
int[,] mapFlags = new int[width, height];
for (int x = 0; x < width; ++x)
{
for (int y = 0; y < height; ++y)
{
if(mapFlags[x, y] == 0 && map[x,y] == tileType)
{
List<Coord> newRegion = GetRegionTiles(x, y);
regions.Add(newRegion);
foreach(Coord tile in newRegion)
{
mapFlags[tile.tileX, tile.tileY] = 1;
}
}
}
}
return regions;
}
List<Coord> GetRegionTiles(int startX, int startY)
{
List<Coord> tiles = new List<Coord>();
int[,] mapFlags = new int[width, height];
int tileType = map[startX, startY];
Queue<Coord> queue = new Queue<Coord>();
queue.Enqueue(new Coord(startX, startY));
mapFlags[startX, startY] = 1;
while (queue.Count > 0)
{
Coord tile = queue.Dequeue();
tiles.Add(tile);
for (int x = tile.tileX - 1; x <= tile.tileX + 1; ++x)
{
for (int y = tile.tileY - 1; y <= tile.tileY + 1; ++y)
{
if (CheckIfInMapBounds(x, y) && (y == tile.tileY || x == tile.tileX))
{
if (mapFlags[x, y] == 0 && map[x, y] == tileType)
{
mapFlags[x, y] = 1;
queue.Enqueue(new Coord(x, y));
}
}
}
}
}
return tiles;
}
void SmoothMap()
{
int[,] newMap = new int [width, height];
for (int x = 0; x < width; ++x)
{
for (int y = 0; y < height; ++y)
{
newMap[x, y] = DetermineState(x, y);
}
}
map = newMap;
}
int DetermineState(int x, int y)
{
if (cave)
{
int neighbourWalls = GetSurroundingWallCount(x, y);
if (neighbourWalls > 4)
{
return 1;
}
else if (neighbourWalls < 4)
{
return 0;
}
return map[x, y];
}
else
{
if (!CheckIfInMapBounds(x - 1, y) || !CheckIfInMapBounds(x + 1, y) ||
!CheckIfInMapBounds(x, y - 1) || !CheckIfInMapBounds(x, y + 1))
{
return 1;
}
if (!CheckIfInMapBounds(x - 2, y) || !CheckIfInMapBounds(x + 2, y) ||
!CheckIfInMapBounds(x, y - 2) || !CheckIfInMapBounds(x, y + 2))
{
return map[x, y];
}
if ((map[x + 1, y] == 1 && map[x - 1 , y] == 1 && (map[x + 2, y] == 1 || map[x - 2, y] == 1)) ||
(map[x, y + 1] == 1 && map[x, y - 1] == 1 && (map[x, y + 2] == 1 || map[x, y - 2] == 1)))
{
return 1;
}
return 0;
}
}
bool CheckIfInMapBounds(int x, int y)
{
return (x >= 0 && x < width && y >= 0 && y < height);
}
int GetSurroundingWallCount(int gridX, int gridY)
{
int wallCount = 0;
for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; ++neighbourX)
{
for (int neighbourY = gridY- 1; neighbourY <= gridY + 1; ++neighbourY)
{
if (CheckIfInMapBounds(neighbourX, neighbourY))
{
if ((neighbourX != gridX || neighbourY != gridY))
{
wallCount += map[neighbourX, neighbourY];
}
}
else
{
wallCount++;
}
}
}
return wallCount;
}
void FillMap()
{
for(int x = 0; x < width; ++x)
{
for(int y = 0; y < height; ++y)
{
if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
{
map[x, y] = 1;
}
else
{
map[x, y] = (generator.Next(0, 100) < randomFillPercent) ? 1 : 0;
}
}
}
}
struct Coord
{
public int tileX;
public int tileY;
public Coord(int x, int y)
{
tileX = x;
tileY = y;
}
}
class Room : IComparable<Room>
{
public List<Coord> m_Tiles;
public List<Coord> m_EdgeTiles;
public List<Room> m_ConnectedRooms;
public int m_RoomSize;
public bool m_IsAccessibleFromMainRoom;
public bool m_IsMainRoom;
public Room()
{
}
public Room(List<Coord> roomTiles, int[,] map)
{
m_Tiles = roomTiles;
m_RoomSize = m_Tiles.Count;
m_ConnectedRooms = new List<Room>();
m_EdgeTiles = new List<Coord>();
foreach (Coord tile in m_Tiles)
{
for (int x = tile.tileX - 1; x <= tile.tileX + 1; ++x)
{
for (int y = tile.tileY - 1; y <= tile.tileY + 1; ++y)
{
if (x == tile.tileX || x == tile.tileY)
{
if (map[x, y] == 1)
{
m_EdgeTiles.Add(tile);
}
}
}
}
}
}
public void SetAccesibleFromMainRoom()
{
if(!m_IsAccessibleFromMainRoom)
{
m_IsAccessibleFromMainRoom = true;
foreach (Room connectedRoom in m_ConnectedRooms)
{
connectedRoom.SetAccesibleFromMainRoom();
}
}
}
public static void ConnectRooms(Room roomA, Room roomB)
{
if (roomA.m_IsAccessibleFromMainRoom)
{
roomB.SetAccesibleFromMainRoom();
}
else if (roomB.m_IsAccessibleFromMainRoom)
{
roomA.SetAccesibleFromMainRoom();
}
roomA.m_ConnectedRooms.Add(roomB);
roomB.m_ConnectedRooms.Add(roomA);
}
public bool IsConnected(Room otherRoom)
{
return m_ConnectedRooms.Contains(otherRoom);
}
public int CompareTo(Room otherRoom)
{
return otherRoom.m_RoomSize.CompareTo(m_RoomSize);
}
}
}

11
Assets/Scripts/Underground/CaveGenerator.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 13baf1d867f6d5548aec39674d37fa6d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

409
Assets/Scripts/Underground/CaveMeshGenerator.cs Normal file
View File

@ -0,0 +1,409 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CaveMeshGenerator : MonoBehaviour
{
public SquareGrid squareGrid;
public MeshFilter walls;
List<Vector3> vertices;
List<int> triangles;
Dictionary<int, List<Triangle>> triangleDic = new Dictionary<int, List<Triangle>>();
List<List<int>> outlines = new List<List<int>>();
HashSet<int> checkedVertices = new HashSet<int>();
public void GenerateMesh(int[,] map, float squareSize)
{
outlines.Clear();
checkedVertices.Clear();
triangleDic.Clear();
squareGrid = new SquareGrid(map, squareSize);
vertices = new List<Vector3>();
triangles = new List<int>();
for (int x = 0; x < squareGrid.squares.GetLength(0); ++x)
{
for (int y = 0; y < squareGrid.squares.GetLength(1); ++y)
{
TriangulateSquare(squareGrid.squares[x, y]);
}
}
Mesh mesh = new Mesh();
GetComponent<MeshFilter>().mesh = mesh;
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.RecalculateNormals();
CreateWallMesh();
}
void CreateWallMesh()
{
CalculateMeshOutlines();
List<Vector3> wallVertices = new List<Vector3>();
List<int> wallTriangles = new List<int>();
Mesh wallMesh = new Mesh();
float wallHeight = 5;
foreach (List<int> outline in outlines)
{
for(int i = 0; i < outline.Count - 1; ++i)
{
int startIndex = wallVertices.Count;
wallVertices.Add(vertices[outline[i]]);
wallVertices.Add(vertices[outline[i + 1]]);
wallVertices.Add(vertices[outline[i]] - Vector3.up * wallHeight);
wallVertices.Add(vertices[outline[i + 1]] - Vector3.up * wallHeight);
wallTriangles.Add(startIndex);
wallTriangles.Add(startIndex + 2);
wallTriangles.Add(startIndex + 3);
wallTriangles.Add(startIndex + 3);
wallTriangles.Add(startIndex + 1);
wallTriangles.Add(startIndex);
}
}
wallMesh.vertices = wallVertices.ToArray();
wallMesh.triangles = wallTriangles.ToArray();
walls.mesh = wallMesh;
walls.sharedMesh = wallMesh;
}
void TriangulateSquare(Square square)
{
switch(square.m_Config)
{
case 0:
break;
case 1:
MeshFromPoints(square.m_CentreLeft, square.m_CentreBottom, square.m_BottomLeft);
break;
case 2:
MeshFromPoints(square.m_BottomRight, square.m_CentreBottom, square.m_CentreRight);
break;
case 4:
MeshFromPoints(square.m_TopRight, square.m_CentreRight, square.m_CentreTop);
break;
case 8:
MeshFromPoints(square.m_TopLeft, square.m_CentreTop, square.m_CentreLeft);
break;
case 3:
MeshFromPoints(square.m_CentreRight, square.m_BottomRight, square.m_BottomLeft, square.m_CentreLeft);
break;
case 6:
MeshFromPoints(square.m_CentreTop, square.m_TopRight, square.m_BottomRight, square.m_CentreBottom);
break;
case 9:
MeshFromPoints(square.m_TopLeft, square.m_CentreTop, square.m_CentreBottom, square.m_BottomLeft);
break;
case 12:
MeshFromPoints(square.m_TopLeft, square.m_TopRight, square.m_CentreRight, square.m_CentreLeft);
break;
case 5:
MeshFromPoints(square.m_CentreTop, square.m_TopRight, square.m_CentreRight, square.m_CentreBottom, square.m_BottomLeft, square.m_CentreLeft);
break;
case 10:
MeshFromPoints(square.m_TopLeft, square.m_CentreTop, square.m_CentreRight, square.m_BottomRight, square.m_CentreBottom, square.m_CentreLeft);
break;
case 7:
MeshFromPoints(square.m_CentreTop, square.m_TopRight, square.m_BottomRight, square.m_BottomLeft, square.m_CentreLeft);
break;
case 11:
MeshFromPoints(square.m_TopLeft, square.m_CentreTop, square.m_CentreRight, square.m_BottomRight, square.m_BottomLeft);
break;
case 13:
MeshFromPoints(square.m_TopLeft, square.m_TopRight, square.m_CentreRight, square.m_CentreBottom, square.m_BottomLeft);
break;
case 14:
MeshFromPoints(square.m_TopLeft, square.m_TopRight, square.m_BottomRight, square.m_CentreBottom, square.m_CentreLeft);
break;
case 15:
MeshFromPoints(square.m_TopLeft, square.m_TopRight, square.m_BottomRight, square.m_BottomLeft);
checkedVertices.Add(square.m_TopLeft.m_VertexIndex);
checkedVertices.Add(square.m_TopRight.m_VertexIndex);
checkedVertices.Add(square.m_BottomRight.m_VertexIndex);
checkedVertices.Add(square.m_BottomLeft.m_VertexIndex);
break;
}
}
void MeshFromPoints(params Node[] points)
{
AssignVertices(points);
if(points.Length >= 3)
{
CreateTriangle(points[0], points[1], points[2]);
}
if(points.Length >= 4)
{
CreateTriangle(points[0], points[2], points[3]);
}
if (points.Length >= 5)
{
CreateTriangle(points[0], points[3], points[4]);
}
if (points.Length >= 6)
{
CreateTriangle(points[0], points[4], points[5]);
}
}
void AssignVertices(Node[] points)
{
for(int i = 0; i < points.Length; ++i)
{
if(points[i].m_VertexIndex == -1)
{
points[i].m_VertexIndex = vertices.Count;
vertices.Add(points[i].m_Position);
}
}
}
void CreateTriangle(Node a, Node b, Node c)
{
triangles.Add(a.m_VertexIndex);
triangles.Add(b.m_VertexIndex);
triangles.Add(c.m_VertexIndex);
Triangle triangle = new Triangle(a.m_VertexIndex, b.m_VertexIndex, c.m_VertexIndex);
AddTriangleToDictionary(triangle.vertexIndexA, triangle);
AddTriangleToDictionary(triangle.vertexIndexB, triangle);
AddTriangleToDictionary(triangle.vertexIndexC, triangle);
}
void AddTriangleToDictionary(int vertexIndexKey, Triangle triangle)
{
if (triangleDic.ContainsKey(vertexIndexKey))
{
triangleDic[vertexIndexKey].Add(triangle);
}
else
{
List<Triangle> triangles = new List<Triangle>();
triangles.Add(triangle);
triangleDic.Add(vertexIndexKey, triangles);
}
}
void CalculateMeshOutlines()
{
for(int vertexIndex = 0; vertexIndex < vertices.Count; ++vertexIndex)
{
if (!checkedVertices.Contains(vertexIndex))
{
int newOutlineVertex = GetConnectedOutlineVertex(vertexIndex);
if (newOutlineVertex != -1)
{
checkedVertices.Add(vertexIndex);
List<int> newOutline = new List<int>();
newOutline.Add(vertexIndex);
outlines.Add(newOutline);
FollowOutline(newOutlineVertex, outlines.Count - 1);
outlines[outlines.Count - 1].Add(vertexIndex);
}
}
}
}
// TODO: change to non recursive
void FollowOutline(int vertexIndex, int outlineIndex)
{
outlines[outlineIndex].Add(vertexIndex);
checkedVertices.Add(vertexIndex);
int nextVertexIndex = GetConnectedOutlineVertex(vertexIndex);
if (nextVertexIndex != -1)
{
FollowOutline(nextVertexIndex, outlineIndex);
}
}
int GetConnectedOutlineVertex(int vertexIndex)
{
List<Triangle> trianglesContainingVertex = triangleDic[vertexIndex];
for (int i = 0; i < trianglesContainingVertex.Count; ++i)
{
Triangle triangle = trianglesContainingVertex[i];
for (int j = 0; j < 3; ++j)
{
int vertexB = triangle[j];
if (vertexB == vertexIndex || checkedVertices.Contains(vertexB))
{
continue;
}
if (IsOutlineEdge(vertexIndex, vertexB))
{
return vertexB;
}
}
}
return -1;
}
bool IsOutlineEdge(int vertexA, int vertexB)
{
List<Triangle> trianglesContainingVertexA = triangleDic[vertexA];
int sharedTriangleCount = 0;
for (int i = 0; i < trianglesContainingVertexA.Count; ++i)
{
if (trianglesContainingVertexA[i].Contains(vertexB))
{
++sharedTriangleCount;
if (sharedTriangleCount == 2)
{
return false;
}
}
}
return true;
}
struct Triangle
{
public int vertexIndexA;
public int vertexIndexB;
public int vertexIndexC;
int[] vertices;
public Triangle(int a, int b, int c)
{
vertexIndexA = a;
vertexIndexB = b;
vertexIndexC = c;
vertices = new int[3];
vertices[0] = a;
vertices[1] = b;
vertices[2] = c;
}
public int this[int i]
{
get
{
return vertices[i];
}
}
public bool Contains(int vertexIndex)
{
return vertexIndex == vertexIndexA ||
vertexIndex == vertexIndexB ||
vertexIndex == vertexIndexC;
}
}
public class SquareGrid
{
public Square[,] squares;
public SquareGrid(int[,] map, float squareSize)
{
int nodeCountX = map.GetLength(0);
int nodeCountY = map.GetLength(1);
float mapWidth = nodeCountX * squareSize;
float mapHeight = nodeCountY * squareSize;
ControlNode[,] controlNodes = new ControlNode[nodeCountX, nodeCountY];
for(int x = 0; x < nodeCountX; ++x)
{
for (int y = 0; y < nodeCountY; ++y)
{
Vector3 position = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2,
0,
-mapHeight / 2 + y * squareSize + squareSize / 2);
controlNodes[x, y] = new ControlNode(position, map[x, y] == 1, squareSize);
}
}
squares = new Square[nodeCountX - 1, nodeCountY - 1];
for (int x = 0; x < nodeCountX - 1; ++x)
{
for (int y = 0; y < nodeCountY - 1; ++y)
{
squares[x, y] = new Square(controlNodes[x, y + 1],
controlNodes[x + 1, y + 1],
controlNodes[x + 1, y],
controlNodes[x, y]);
}
}
}
}
public class Square
{
public ControlNode m_TopLeft, m_TopRight, m_BottomLeft, m_BottomRight;
public Node m_CentreTop, m_CentreRight, m_CentreBottom, m_CentreLeft;
public int m_Config;
public Square(
ControlNode topLeft,
ControlNode topRight,
ControlNode bottomRight,
ControlNode bottomLeft
)
{
m_TopLeft = topLeft;
m_TopRight = topRight;
m_BottomLeft = bottomLeft;
m_BottomRight = bottomRight;
m_CentreTop = m_TopLeft.m_RightNode;
m_CentreRight = m_BottomRight.m_AboveNode;
m_CentreBottom = m_BottomLeft.m_RightNode;
m_CentreLeft = m_BottomLeft.m_AboveNode;
m_Config = ((m_TopLeft.m_IsActive) ? 8 : 0) |
((m_TopRight.m_IsActive) ? 4 : 0) |
((m_BottomRight.m_IsActive) ? 2 : 0) |
(m_BottomLeft.m_IsActive ? 1 : 0);
}
}
public class Node
{
public Vector3 m_Position;
public int m_VertexIndex = -1;
public Node(Vector3 pos)
{
m_Position = pos;
}
}
public class ControlNode : Node
{
public bool m_IsActive;
public Node m_AboveNode, m_RightNode;
public ControlNode(Vector3 pos, bool isActive, float squareSize) : base(pos)
{
m_IsActive = isActive;
m_AboveNode = new Node(pos + Vector3.forward * squareSize / 2f);
m_RightNode = new Node(pos + Vector3.right * squareSize / 2f);
}
}
}

11
Assets/Scripts/Underground/CaveMeshGenerator.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 9abca64ae9492714ea50728ba203f24b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: