public void Regenerate(bool rebuild = false)
{
float tStart = Time.realtimeSinceStartup;
string path = levelDirectory + gameObject.name + ".asset";
if (!rebuild && Map.IsMap(path))
{
map = Map.Read(path);
}
else
{
map = Map.Generate(new DepthFirstGenerator(width, height));
if (!Application.isPlaying)
{
map.SaveToFile(path);
}
}
MeshFilter filter = GetComponent<MeshFilter>();
if (filter == null)
gameObject.AddComponent<MeshFilter>();
ProceduralMesh pm = new ProceduralMesh();
pm.Generate(map);
pm.Compile();
GetComponent<MeshCollider>().sharedMesh = pm.Mesh;
filter.sharedMesh = pm.Mesh;
float tEnd = Time.realtimeSinceStartup;
float tTotal = tEnd - tStart;
Debug.Log("Level Regenerate( Maze: " + rebuild + " ). Time: " + tTotal);
}
public void DisplayArea()
{
if (area != null) {
DestroyImmediate (area);
}
area = new GameObject ("Area");
area.hideFlags = HideFlags.HideInHierarchy;
area.transform.parent = transform;
area.transform.localPosition = Vector3.zero;
area.transform.localRotation = Quaternion.identity;
int numVoxels = queryMask.Length;
if (numVoxels > 1820) {
Debug.LogError ("number of voxels cannot be > 1820");
enabled = false;
return;
}
ProceduralMesh mesh = new ProceduralMesh (numVoxels * 24, numVoxels * 36);
float yOffset = (-queryHeight * 0.5f) * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
float zOffset = (-queryDepth * 0.5f) * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
float xOffset = (-queryWidth * 0.5f) * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
Vector3 yStart = new Vector3 (0.0f, yOffset, 0.0f);
int queryDepth_x_queryWidth = queryDepth * queryWidth;
for (int y = 0; y < queryHeight; y++) {
int y1 = y * queryDepth_x_queryWidth;
Vector3 zStart = new Vector3 (0.0f, 0.0f, zOffset);
for (int z = 0; z < queryDepth; z++) {
int z1 = z * queryWidth;
Vector3 xStart = new Vector3 (xOffset, 0.0f, 0.0f);
for (int x = 0; x < queryWidth; x++) {
Vector3 center = yStart + zStart + xStart;
if (queryMask [y1 + z1 + x]) {
ProceduralMeshes.CreateCube (mesh, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, center);
}
xStart += VoxelEngine.instance.right;
}
zStart += VoxelEngine.instance.forward;
}
yStart += VoxelEngine.instance.up;
}
Mesh areaMesh = mesh.Build ();
MeshFilter meshFilter;
if ((meshFilter = area.GetComponent<MeshFilter> ()) == null) {
meshFilter = area.AddComponent<MeshFilter> ();
}
meshFilter.sharedMesh = areaMesh;
MeshRenderer meshRenderer;
if ((meshRenderer = area.GetComponent<MeshRenderer> ()) == null) {
meshRenderer = area.AddComponent<MeshRenderer> ();
}
meshRenderer.sharedMaterial = GetVoxelRemoverMaterial ();
}
void OnDrawGizmos()
{
if (prodMesh == null)
{
prodMesh = GetComponentInParent<ProceduralMesh>();
}
Vector3 islandPosition = this.transform.position;
Vector3 startPosition = islandPosition - new Vector3(prodMesh.xSize*0.5f, 0.0f, prodMesh.ySize*0.5f);
Vector3 endPosition = islandPosition + new Vector3(prodMesh.xSize*0.5f, 0.0f, prodMesh.ySize*0.5f);
for(float x = startPosition.x;x<endPosition.x;x+=cellSize )
{
Debug.DrawLine(new Vector3(x, 5.0f, startPosition.z), new Vector3(x, 5.0f, endPosition.z));
}
for (float z = startPosition.z; z < endPosition.z; z += cellSize)
{
Debug.DrawLine(new Vector3(startPosition.x, 5.0f, z), new Vector3(endPosition.x, 5.0f, z));
}
}
public static void CreateCube(ProceduralMesh mesh, float width, float height, float depth, Vector3 center, int excludeFaces = 0)
{
CreateCube (mesh, width, height, depth, center, DEFAULT_CUBIC_UVS, excludeFaces);
}
public static void CreateCube(ProceduralMesh mesh, float width, float height, float depth, Vector3 center, Rect[] uvRect, int excludeFaces = 0)
{
float halfWidth = width * 0.5f;
float halfHeight = height * 0.5f;
float halfDepth = depth * 0.5f;
bool hasFrontFace = (excludeFaces & (int)FaceDirection.FRONT) == 0,
hasTopFace = (excludeFaces & (int)FaceDirection.TOP) == 0,
hasRightFace = (excludeFaces & (int)FaceDirection.RIGHT) == 0,
hasBackFace = (excludeFaces & (int)FaceDirection.BACK) == 0,
hasBottomFace = (excludeFaces & (int)FaceDirection.BOTTOM) == 0,
hasLeftFace = (excludeFaces & (int)FaceDirection.LEFT) == 0;
int i = mesh.vertexCount;
// front
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, -halfDepth));
// top
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, -halfDepth));
// right
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, -halfDepth));
// back
mesh.AddVertex (center + new Vector3 (halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, halfDepth));
// bottom
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (halfWidth, -halfHeight, halfDepth));
// left
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, -halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, halfDepth));
mesh.AddVertex (center + new Vector3 (-halfWidth, -halfHeight, -halfDepth));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, -1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, -1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, -1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, -1.0f));
mesh.AddNormal (new Vector3 (0.0f, 1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, 1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, 1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, 1.0f, 0.0f));
mesh.AddNormal (new Vector3 (1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, 1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, 1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, 1.0f));
mesh.AddNormal (new Vector3 (0.0f, 0.0f, 1.0f));
mesh.AddNormal (new Vector3 (0.0f, -1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, -1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, -1.0f, 0.0f));
mesh.AddNormal (new Vector3 (0.0f, -1.0f, 0.0f));
mesh.AddNormal (new Vector3 (-1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (-1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (-1.0f, 0.0f, 0.0f));
mesh.AddNormal (new Vector3 (-1.0f, 0.0f, 0.0f));
// front
mesh.AddUv (new Vector2 (uvRect [0].xMin, uvRect [0].yMax));
mesh.AddUv (new Vector2 (uvRect [0].xMax, uvRect [0].yMax));
mesh.AddUv (new Vector2 (uvRect [0].xMax, uvRect [0].yMin));
mesh.AddUv (new Vector2 (uvRect [0].xMin, uvRect [0].yMin));
// top
mesh.AddUv (new Vector2 (uvRect [1].xMin, uvRect [1].yMax));
mesh.AddUv (new Vector2 (uvRect [1].xMax, uvRect [1].yMax));
mesh.AddUv (new Vector2 (uvRect [1].xMax, uvRect [1].yMin));
mesh.AddUv (new Vector2 (uvRect [1].xMin, uvRect [1].yMin));
// right
mesh.AddUv (new Vector2 (uvRect [2].xMin, uvRect [2].yMax));
mesh.AddUv (new Vector2 (uvRect [2].xMax, uvRect [2].yMax));
mesh.AddUv (new Vector2 (uvRect [2].xMax, uvRect [2].yMin));
mesh.AddUv (new Vector2 (uvRect [2].xMin, uvRect [2].yMin));
// back
mesh.AddUv (new Vector2 (uvRect [3].xMin, uvRect [3].yMax));
mesh.AddUv (new Vector2 (uvRect [3].xMax, uvRect [3].yMax));
mesh.AddUv (new Vector2 (uvRect [3].xMax, uvRect [3].yMin));
mesh.AddUv (new Vector2 (uvRect [3].xMin, uvRect [3].yMin));
// bottom
mesh.AddUv (new Vector2 (uvRect [4].xMin, uvRect [4].yMin));
mesh.AddUv (new Vector2 (uvRect [4].xMax, uvRect [4].yMin));
mesh.AddUv (new Vector2 (uvRect [4].xMax, uvRect [4].yMax));
mesh.AddUv (new Vector2 (uvRect [4].xMin, uvRect [4].yMax));
// left
mesh.AddUv (new Vector2 (uvRect [5].xMin, uvRect [5].yMax));
mesh.AddUv (new Vector2 (uvRect [5].xMax, uvRect [5].yMax));
mesh.AddUv (new Vector2 (uvRect [5].xMax, uvRect [5].yMin));
mesh.AddUv (new Vector2 (uvRect [5].xMin, uvRect [5].yMin));
// front
if (hasFrontFace) {
mesh.AddIndex (i);
mesh.AddIndex (i + 1);
mesh.AddIndex (i + 2);
mesh.AddIndex (i);
mesh.AddIndex (i + 2);
mesh.AddIndex (i + 3);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
// top
if (hasTopFace) {
mesh.AddIndex (i + 4);
mesh.AddIndex (i + 5);
mesh.AddIndex (i + 6);
mesh.AddIndex (i + 4);
mesh.AddIndex (i + 6);
mesh.AddIndex (i + 7);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
// right
if (hasRightFace) {
mesh.AddIndex (i + 8);
mesh.AddIndex (i + 9);
mesh.AddIndex (i + 10);
mesh.AddIndex (i + 8);
mesh.AddIndex (i + 10);
mesh.AddIndex (i + 11);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
// back
if (hasBackFace) {
mesh.AddIndex (i + 12);
mesh.AddIndex (i + 13);
mesh.AddIndex (i + 14);
mesh.AddIndex (i + 12);
mesh.AddIndex (i + 14);
mesh.AddIndex (i + 15);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
// bottom
if (hasBottomFace) {
mesh.AddIndex (i + 16);
mesh.AddIndex (i + 18);
mesh.AddIndex (i + 17);
mesh.AddIndex (i + 16);
mesh.AddIndex (i + 19);
mesh.AddIndex (i + 18);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
// left
if (hasLeftFace) {
mesh.AddIndex (i + 20);
mesh.AddIndex (i + 22);
mesh.AddIndex (i + 21);
mesh.AddIndex (i + 20);
mesh.AddIndex (i + 23);
mesh.AddIndex (i + 22);
} else {
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
mesh.AddIndex (0);
}
}
// Use this for initialization
void Start()
{
prodMesh = GetComponentInParent<ProceduralMesh>();
}
protected override Mesh CreateMesh()
{
return(ProceduralMesh.Torus(majorRadius, minorRadius, thetaSegments, phiSegments));
}
public override void Modify(Vector3[] vertices)
{
ProceduralMesh.Twist(vertices, axis.normalized, strength, center);
}
public void Build()
{
if (width < 1 || height < 1 || depth < 1) {
// Debug.LogError ("width or height or depth < 1");
enabled = false;
return;
}
if (data == null) {
// Debug.LogError ("data == null");
enabled = false;
return;
}
int numVoxels = data.Length;
if (numVoxels > 1820) {
// Debug.LogError ("number of voxels cannot be > 1820");
enabled = false;
return;
}
depth_x_width = depth * width;
float halfWidth = width * 0.5f;
float halfHeight = height * 0.5f;
float halfDepth = depth * 0.5f;
offset = new Vector3 (halfWidth * VoxelEngine.instance.voxelSize, halfHeight * VoxelEngine.instance.voxelSize, halfDepth * VoxelEngine.instance.voxelSize);
ProceduralMesh mesh = new ProceduralMesh (numVoxels * 24, numVoxels * 36);
float yOffset = -halfHeight * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
float zOffset = -halfDepth * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
float xOffset = -halfWidth * VoxelEngine.instance.voxelSize + VoxelEngine.instance.halfVoxelSize;
Vector3 yStart = new Vector3 (0.0f, yOffset, 0.0f);
Rect[] uvRects = new Rect[6];
for (int y = 0; y < height; y++) {
int y1 = y * depth_x_width;
Vector3 zStart = new Vector3 (0.0f, 0.0f, zOffset);
for (int z = 0; z < depth; z++) {
int z1 = z * width;
Vector3 xStart = new Vector3 (xOffset, 0.0f, 0.0f);
for (int x = 0; x < width; x++) {
Vector3 center = yStart + zStart + xStart;
byte voxelId = data [y1 + z1 + x].id;
if (voxelId > 0) {
int excludeFaces = 0;
if (HasFrontNeighbor (x, y1, z)) {
excludeFaces |= (int)FaceDirection.FRONT;
}
bool hasTopNeighbor;
if ((hasTopNeighbor = HasTopNeighbor (x, y, z1))) {
excludeFaces |= (int)FaceDirection.TOP;
}
if (HasRightNeighbor (x, y1, z1)) {
excludeFaces |= (int)FaceDirection.RIGHT;
}
if (HasBottomNeighbor (x, y, z1)) {
excludeFaces |= (int)FaceDirection.BOTTOM;
}
if (HasBackNeighbor (x, y1, z)) {
excludeFaces |= (int)FaceDirection.BACK;
}
if (HasLeftNeighbor (x, y1, z1)) {
excludeFaces |= (int)FaceDirection.LEFT;
}
int frontFaceTileId, topFaceTileId, rightFaceTileId, backFaceTileId, bottomFaceTileId, leftFaceTileId;
VoxelEngine.instance.GetVoxelFaceMapping (voxelId, out frontFaceTileId, out topFaceTileId, out rightFaceTileId, out backFaceTileId, out bottomFaceTileId, out leftFaceTileId, hasTopNeighbor);
// front
uvRects [0] = VoxelEngine.instance.GetTileUv (frontFaceTileId);
// top
uvRects [1] = VoxelEngine.instance.GetTileUv (topFaceTileId);
// right
uvRects [2] = VoxelEngine.instance.GetTileUv (rightFaceTileId);
// back
uvRects [3] = VoxelEngine.instance.GetTileUv (backFaceTileId);
// bottom
uvRects [4] = VoxelEngine.instance.GetTileUv (bottomFaceTileId);
// left
uvRects [5] = VoxelEngine.instance.GetTileUv (leftFaceTileId);
ProceduralMeshes.CreateCube (mesh, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, center, uvRects, excludeFaces);
} else {
ProceduralMeshes.CreateCube (mesh, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, VoxelEngine.instance.voxelSize, center, EMPTY_UV_RECTS, EXCLUDE_ALL_FACES);
}
xStart += VoxelEngine.instance.right;
}
zStart += VoxelEngine.instance.forward;
}
yStart += VoxelEngine.instance.up;
}
chunkMesh = mesh.Build ();
chunkMesh.MarkDynamic ();
if ((meshFilter = gameObject.GetComponent<MeshFilter> ()) == null) {
meshFilter = gameObject.AddComponent<MeshFilter> ();
}
meshFilter.sharedMesh = chunkMesh;
if ((meshCollider = gameObject.GetComponent<MeshCollider> ()) == null) {
meshCollider = gameObject.AddComponent<MeshCollider> ();
}
meshCollider.sharedMesh = chunkMesh;
MeshRenderer meshRenderer;
if ((meshRenderer = gameObject.GetComponent<MeshRenderer> ()) == null) {
meshRenderer = gameObject.AddComponent<MeshRenderer> ();
}
meshRenderer.sharedMaterial = VoxelEngine.instance.atlas;
built = true;
}
public override void Modify(Vector3[] vertices)
{
ProceduralMesh.Transform(vertices, offset);
}
// Use this for initialization
void Start()
{
proceduralMesh = GameObject.FindObjectOfType<ProceduralMesh>();
spawnMesh();
}
protected override Mesh CreateMesh()
{
return(ProceduralMesh.Cylinder(height, radius, heightSegments, angleSegments));
}
protected override Mesh CreateMesh()
{
return(ProceduralMesh.Sphere(radius, thetaSegments, phiSegments));
}
public override void Modify(Vector3[] vertices)
{
Quaternion quaternion = Quaternion.Euler(rotation);
ProceduralMesh.Rotate(vertices, quaternion);
}
public override Mesh CreateMesh()
{
return(ProceduralMesh.Cylinder(height, radius, heightSegments, angleSegments, NO_RECALCULATION_OPTION));
}
public override void Modify(Vector3[] vertices)
{
ProceduralMesh.Scale(vertices, scale);
}
