public RaycastResult?AlaphaRaycast(Vector3 position, Vector3 direction, float distance = 20) { Vector3 increase = Vector3.Normalize(direction) * 0.05f; Point3 last = new Point3(); Point3 result; int count = (int)(distance / 0.05f); for (int i = 0; i < count; i++) { result = new Point3(ToCell(position.x), ToCell(position.y), ToCell(position.z)); if (!result.Equals(last)) { int value = terrain.GetCellValue(result.X, result.Y, result.Z); if (value != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(value) != 0) { return(new RaycastResult { Position = result, LastPosition = last, BlockValue = value, Distance = i * 0.05f }); } last = result; } position += increase; } return(null); }
public void GenerateTerrain(int x, int y, int z, int value, int face, BlockTerrain.Chunk chunk, ref CellFace data) { int?color = GetColor(BlockTerrain.GetData(value)); data.TextureSlot = color.HasValue ? BlocksData.paintedTextures[TextureSlot] : TextureSlot; data.Color = BlocksData.ColorFromInt(color); }
public unsafe void SaveChunk(BlockTerrain.Chunk chunk) { if (!chunk.isEdited) { return; } lock (locker) { Point2 p = new Point2(chunk.chunkx, chunk.chunky); long value; if (chunkOffsets.TryGetValue(p, out value)) { stream.Seek(value, SeekOrigin.Begin); WriteChunkHeader(stream, chunk.chunkx, chunk.chunky); fixed(byte *bptr = &buffer[0]) { int *iptr = (int *)bptr; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { int index = BlockTerrain.GetCellIndex(15 - x, 0, y); int h = 0; while (h < 128) { *iptr = chunk.GetCellValue(index); iptr++; h++; index++; } } } } stream.Write(buffer, 0, 131072); fixed(byte *bptr = &buffer[0]) { int *iptr = (int *)bptr; for (int x = 0; x < 16; x++) { int index = BlockTerrain.GetShiftIndex(15 - x, 0); int h = 0; while (h < 16) { *iptr = chunk.GetShiftValue(index); iptr++; h++; index++; } } } stream.Write(buffer, 0, 1024); } } }
// public void SaveChunkEntries () // { // Point2[] entries = new Point2[chunkOffsets.Count]; // foreach (KeyValuePair<Point2, long> p in chunkOffsets) { // entries [(int)((p.Value - 786444L) / 132112L)] = p.Key; // } // // stream.Seek (0, SeekOrigin.Begin); // for (int i = 0; i < entries.Length; i++) { // WriteChunkEntry (stream, -entries [i].X, entries [i].Y, i); // } // } public unsafe void ReadChunk(int chunkx, int chunky, BlockTerrain.Chunk chunk) { lock (locker) { Point2 p = new Point2(chunkx, chunky); long value; if (chunkOffsets.TryGetValue(p, out value)) { stream.Seek(value, SeekOrigin.Begin); ReadChunkHeader(stream); stream.Read(buffer, 0, 131072); fixed(byte *bptr = &buffer[0]) { int *iptr = (int *)bptr; for (int x = 0; x < 16; x++) { for (int y = 0; y < 16; y++) { int index = BlockTerrain.GetCellIndex(15 - x, 0, y); int h = 0; while (h < 128) { chunk.SetCellValue(index, *iptr); iptr++; h++; index++; } } } } stream.Read(buffer, 0, 1024); fixed(byte *bptr = &buffer[0]) { int *iptr = (int *)bptr; for (int x = 0; x < 16; x++) { int index = BlockTerrain.GetShiftIndex(15 - x, 0); int h = 0; while (h < 16) { chunk.SetShiftValue(index, *iptr); iptr++; h++; index++; } } } } } }
public static int GetBlockColorInt(Block block, int value) { IPaintableBlock paintable = block as IPaintableBlock; if (paintable == null) { return(0); } return(paintable.GetColor(BlockTerrain.GetData(value)) ?? 0); }
public void Load() { Debug.Log("loading terrain: " + BlockTerrain.terrainSize); Terrain = new BlockTerrain(); LoadTerrain(WorldManager.ChunkDat); Camera.main.transform.position = WorldManager.Project.PlayerPosition; Point2 p = CurrentChunk(); Terrain.chunkStats.SetOffset(p.X + 2000, p.Y + 2000); }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { int?color = GetColor(BlockTerrain.GetData(value)); if (color.HasValue) { g.Terrain.Mesh(x, y, z, paintedBlockMeshes[GetVariant(BlockTerrain.GetData(value))], BlocksData.DEFAULT_COLORS[color.Value]); } else { g.Terrain.Mesh(x, y, z, blockMeshes[GetVariant(BlockTerrain.GetData(value))], Color.white); } }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { int d = BlockTerrain.GetData(value); if (furnitureManager.isTransparent[GetDesignIndex(d)]) { g.AlphaTest.Mesh(x, y, z, furnitureManager.GetFurniture(GetDesignIndex(d), GetRotation(d))); } else { g.Terrain.Mesh(x, y, z, furnitureManager.GetFurniture(GetDesignIndex(d), GetRotation(d))); } }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { int data = BlockTerrain.GetData(value); int?i = GetColor(data); GreedyTerrainMesh terrainMesh = useAlphaTest ? g.AlphaTest : g.Terrain; if (i.HasValue) { terrainMesh.Mesh(x, y, z, paintedBlockMeshes[GetVariant(data)], BlocksData.DEFAULT_COLORS[i.Value]); } else { terrainMesh.Mesh(x, y, z, blockMeshes[GetVariant(data)], unpaintedColor); } }
public override void OnSetToCurrent() { Console.AssignCommand("setData", delegate(string[] args) { if (terrainRaycast.LookingAt.HasValue) { Point3 p = terrainRaycast.LookingAt.Value.Position; terrainManager.ChangeCell(p.X, p.Y, p.Z, BlockTerrain.ReplaceData(terrainManager.Terrain.GetCellValue(p.X, p.Y, p.Z), int.Parse(args[0]))); } }); Console.AssignCommand("setContent", delegate(string[] args) { placeBlockValue = int.Parse(args[0]); }); }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { switch (GetFace(BlockTerrain.GetData(value))) { case 1: g.AlphaTest.TwoSidedQuad( new Vector3(x, y, z), new Vector3(x, y + 1.0f, z), new Vector3(x, y + 1.0f, z + 1.0f), new Vector3(x, y, z + 1.0f), TextureSlot, map.Lookup(chunk.GetShiftValue(x, z)) ); break; case 0: g.AlphaTest.TwoSidedQuad( new Vector3(x, y, z + 1.0f), new Vector3(x, y + 1.0f, z + 1.0f), new Vector3(x + 1.0f, y + 1.0f, z + 1.0f), new Vector3(x + 1.0f, y, z + 1.0f), TextureSlot, map.Lookup(chunk.GetShiftValue(x, z)) ); break; case 3: g.AlphaTest.TwoSidedQuad( new Vector3(x + 1.0f, y, z + 1.0f), new Vector3(x + 1.0f, y + 1.0f, z + 1.0f), new Vector3(x + 1.0f, y + 1.0f, z), new Vector3(x + 1.0f, y, z), TextureSlot, map.Lookup(chunk.GetShiftValue(x, z)) ); break; case 2: g.AlphaTest.TwoSidedQuad( new Vector3(x + 1.0f, y, z), new Vector3(x + 1.0f, y + 1.0f, z), new Vector3(x, y + 1.0f, z), new Vector3(x, y, z), TextureSlot, map.Lookup(chunk.GetShiftValue(x, z)) ); break; default: throw new UnityException("undefined face: " + GetFace(BlockTerrain.GetData(value))); } }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { int textureSlot = GetIsSmall(BlockTerrain.GetData(value)) ? 84 : 85; Color color = GrassBlock.map.Lookup(chunk.GetShiftValue(x, z)); g.AlphaTest.TwoSidedQuad(new Vector3(x, y, z), new Vector3(x + 1.0f, y, z + 1.0f), new Vector3(x + 1.0f, y + 1.0f, z + 1.0f), new Vector3(x, y + 1.0f, z), textureSlot, color); g.AlphaTest.TwoSidedQuad(new Vector3(x, y, z + 1.0f), new Vector3(x + 1.0f, y, z), new Vector3(x + 1.0f, y + 1.0f, z), new Vector3(x, y + 1.0f, z + 1.0f), textureSlot, color); }
float CalculateNeighborHeight(int value) { int num = BlockTerrain.GetContent(value); if (IsTheSameFluid(num)) { int data = BlockTerrain.GetData(value); if (GetIsTop(data)) { return(GetLevelHeight(GetLevel(data))); } return(1f); } if (num == 0) { return(0.01f); } return(0f); }
public void ChangeCell(int x, int y, int z, int newValue) { int index = Terrain.GetChunkIndex(x >> 4, z >> 4); BlockTerrain.Chunk c = Terrain.GetChunk(index); BlockTerrain.ChunkStatics state = Terrain.chunkStats.Get(index); if (c != null) { int cx = x & 15; int cz = z & 15; int content = c.GetCellContent(cx, y, cz); if (content != 0) { state.state = 3; } content = BlockTerrain.GetContent(newValue); if (content != 0) { state.state = 3; } c.SetCellValue(cx, y, cz, newValue); c.isEdited = true; if (cx == 0 && c.XminusOne != null) { QuqueChunkUpdate(c.XminusOne.index, 3); } else if (cx == 15 && c.XplusOne != null) { QuqueChunkUpdate(c.XplusOne.index, 3); } if (cz == 0 && c.YminusOne != null) { QuqueChunkUpdate(c.YminusOne.index, 3); } else if (cz == 15 && c.YplusOne != null) { QuqueChunkUpdate(c.YplusOne.index, 3); } QuqueChunkUpdate(c.index); } }
public void Load(ProjectData project) { XElement designs = project.GetSubsystem("FurnitureBlockBehavior").GetValues("FurnitureDesigns"); List <Furniture> fs = new List <Furniture>(); List <int> isTrans = new List <int>(); foreach (XElement elem in designs.Elements("Values")) { fs.Add(LoadFurniture(elem)); } int count = 0; foreach (Furniture f in fs) { int[] data = f.Data; count = Mathf.Max(count, f.Index); for (int i = 0; i < data.Length; i++) { if (BlockTerrain.GetContent(data[i]) == 15) { isTrans.Add(f.Index); break; } } } isTransparent = new bool[count + 1]; foreach (int i in isTrans) { isTransparent[i] = true; } foreach (Furniture f in fs) { if (f.TerrainUseCount > 0) { LoadMash(f); } } }
void Export(string exportPath) { BlockTerrain terrain = FindObjectOfType <TerrainManager>().Terrain; int[] chunks = FindObjectOfType <ChunkRenderer>().RenderingChunks; List <Mesh> ms = new List <Mesh>(); List <Matrix4x4> ts = new List <Matrix4x4>(); for (int i = 0; i < chunks.Length; i++) { ChunkInstance instance = terrain.chunkInstances[chunks[i]]; ms.Add(instance.Meshes[0]); ts.Add(instance.transform); ms.Add(instance.Meshes[1]); ts.Add(instance.transform); } Export(exportPath, ms.ToArray(), ts.ToArray()); }
public void GenerateNormalBlocks(BlockTerrain.Chunk chunk) { bool[] isTransparent = BlocksData.IsTransparent; INormalBlock[] normalBlocks = BlocksData.NormalBlocks; for (int x = 0; x < 16; x++) { for (int z = 0; z < 16; z++) { for (int y = 0; y < 128; y++) { int value = chunk.GetCellValue(x, y, z); int content = BlockTerrain.GetContent(value); if (isTransparent[content]) { normalBlocks[content].GenerateTerrain(x, y, z, value, chunk, this); } } } } }
private void Start() { Terrain = GetComponent <TerrainManager>().Terrain; string blockTextureName = WorldManager.Project.GameInfo.BlockTextureName; if (!string.IsNullOrEmpty(blockTextureName)) { string path = System.IO.Path.Combine(WorldManager.CurrentEmbeddedContent, blockTextureName); defautTexture.LoadImage(System.IO.File.ReadAllBytes(path)); } try { //Texture2D tex = new Texture2D (TEXTURE_SIZE, TEXTURE_SIZE, TextureFormat.ARGB32, true, true); //tex.filterMode = FilterMode.Point; //tex.LoadImage(System.IO.File.ReadAllBytes(path)); #if GREEDY_MESHING Texture2D main, alphaTest; TextureProcessing.ProcessTexture2(defautTexture, out main, out alphaTest); terrain.mainTexture = main; alaphaTest.mainTexture = alphaTest; terrain.shader = TerrainShader; #else Texture2D tex; TextureProcessing.ProcessTexture(defautTexture, out tex); terrain.mainTexture = tex; alaphaTest.mainTexture = tex; terrain.shader = VertexColorShader; #endif } catch (System.Exception e) { Debug.LogException(e); } }
void OnGUI() { if (showing) { int w = Screen.width, h = Screen.height; GUIStyle style = new GUIStyle(); Rect rect = new Rect(0, 0, w, h * 9 / 100); style.alignment = TextAnchor.UpperLeft; style.fontSize = h * 3 / 100; style.normal.textColor = new Color(1.0f, 1.0f, 1.0f, 1.0f); float msec = deltaTime * 1000.0f; float fps = 1.0f / deltaTime; string text = string.Format("{0:0.0} ms ({1:0.} fps)\ncurrent chunk: {2}\n按ESC键暂停\n按P键截图", msec, fps, TerrainManager.CurrentChunk()); RaycastResult?r = GetComponent <TerrainRaycast>().LookingAt; if (r.HasValue) { //text += string.Format ("\nlooking at {0}", BlocksData.GetBlock(BlockTerrain.GetContent(r.Value.BlockValue)).Name); text += string.Format("\nlooking at {0}", BlocksData.Blocks[BlockTerrain.GetContent(r.Value.BlockValue)].ToString(r.Value.BlockValue)); } GUI.Label(rect, text, style); } }
public BlockSelectionPacker(BlockTerrain terrain) { this.terrain = terrain; root = new XElement("Items"); }
public static int GetFace(int value) { return(BlockTerrain.GetData(value) >> 2 & 7); }
public ChunkStatics Statics(BlockTerrain terrain) { return(terrain.chunkStats.Get(index)); }
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g) { g.AlphaTest.Mesh(x, y, z, meshes[BlockTerrain.GetData(value)], Color.white); }
public void GenerateFluidTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, GreedyTerrainMesh terrainMesh, Color topColor, Color sideColor) { float height1, height2, height3, height4; int data = BlockTerrain.GetData(value); if (GetIsTop(data)) { int cellValueFast = chunk.GetCellValue(x - 1, y, z - 1); int cellValueFast2 = chunk.GetCellValue(x, y, z - 1); int cellValueFast3 = chunk.GetCellValue(x + 1, y, z - 1); int cellValueFast4 = chunk.GetCellValue(x - 1, y, z); int cellValueFast5 = chunk.GetCellValue(x + 1, y, z); int cellValueFast6 = chunk.GetCellValue(x - 1, y, z + 1); int cellValueFast7 = chunk.GetCellValue(x, y, z + 1); int cellValueFast8 = chunk.GetCellValue(x + 1, y, z + 1); float h = CalculateNeighborHeight(cellValueFast); float num = CalculateNeighborHeight(cellValueFast2); float h2 = CalculateNeighborHeight(cellValueFast3); float num2 = CalculateNeighborHeight(cellValueFast4); float num3 = CalculateNeighborHeight(cellValueFast5); float h3 = CalculateNeighborHeight(cellValueFast6); float num4 = CalculateNeighborHeight(cellValueFast7); float h4 = CalculateNeighborHeight(cellValueFast8); float levelHeight = GetLevelHeight(GetLevel(data)); height1 = CalculateFluidVertexHeight(h, num, num2, levelHeight); height2 = CalculateFluidVertexHeight(num, h2, levelHeight, num3); height3 = CalculateFluidVertexHeight(levelHeight, num3, num4, h4); height4 = CalculateFluidVertexHeight(num2, levelHeight, h3, num4); } else { height1 = 1f; height2 = 1f; height3 = 1f; height4 = 1f; } Vector3 v000 = new Vector3(x, y, z); Vector3 v001 = new Vector3(x, y, z + 1f); Vector3 v010 = new Vector3(x, y + height1, z); Vector3 v011 = new Vector3(x, y + height4, z + 1f); Vector3 v100 = new Vector3(x + 1.0f, y, z); Vector3 v101 = new Vector3(x + 1.0f, y, z + 1f); Vector3 v110 = new Vector3(x + 1.0f, y + height2, z); Vector3 v111 = new Vector3(x + 1.0f, y + height3, z + 1f); int v = chunk.GetCellValue(x - 1, y, z); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v001, v011, v010, v000, TextureSlot, sideColor); } v = chunk.GetCellValue(x, y - 1, z); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v000, v100, v101, v001, TextureSlot, sideColor); } v = chunk.GetCellValue(x, y, z - 1); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v000, v010, v110, v100, TextureSlot, sideColor); } v = chunk.GetCellValue(x + 1, y, z); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v100, v110, v111, v101, TextureSlot, sideColor); } v = chunk.GetCellValue(x, y + 1, z); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v111, v110, v010, v011, TextureSlot, topColor); } v = chunk.GetCellValue(x, y, z + 1); if (v != BlockTerrain.NULL_BLOCK_VALUE && BlockTerrain.GetContent(v) != Index) { terrainMesh.NormalQuad(v101, v111, v011, v001, TextureSlot, sideColor); } }
void Start() { terrain = GetComponent <TerrainManager>().Terrain; }
public void GenerateCubeBlocks(BlockTerrain.Chunk chunk) { bool[] isTransparent = BlocksData.IsTransparent; IStandardCubeBlock[] cubeBlocks = BlocksData.StandardCubeBlocks; INormalBlock[] normalBlocks = BlocksData.NormalBlocks; for (int x = 0; x < 16; x++) { for (int z = 0; z < 16; z++) { for (int y = 0; y < 128; y++) { int value = chunk.GetCellValue(x, y, z); int content = BlockTerrain.GetContent(value); if (isTransparent[content]) { normalBlocks[content].GenerateTerrain(x, y, z, value, chunk, this); } else { Vector3 v000 = new Vector3(x, y, z); Vector3 v001 = new Vector3(x, y, z + 1.0f); Vector3 v010 = new Vector3(x, y + 1.0f, z); Vector3 v011 = new Vector3(x, y + 1.0f, z + 1.0f); Vector3 v100 = new Vector3(x + 1.0f, y, z); Vector3 v101 = new Vector3(x + 1.0f, y, z + 1.0f); Vector3 v110 = new Vector3(x + 1.0f, y + 1.0f, z); Vector3 v111 = new Vector3(x + 1.0f, y + 1.0f, z + 1.0f); var cellFace = new CellFace(); var block = cubeBlocks[content]; int neighbor = chunk.GetCellContent(x - 1, y, z); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.BACK, chunk, ref cellFace); Terrain.NormalQuad(v000, v001, v011, v010, cellFace.TextureSlot, cellFace.Color); } neighbor = chunk.GetCellContent(x, y - 1, z); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.BOTTOM, chunk, ref cellFace); Terrain.NormalQuad(v001, v000, v100, v101, cellFace.TextureSlot, cellFace.Color); } neighbor = chunk.GetCellContent(x, y, z - 1); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.LEFT, chunk, ref cellFace); Terrain.NormalQuad(v100, v000, v010, v110, cellFace.TextureSlot, cellFace.Color); } neighbor = chunk.GetCellContent(x + 1, y, z); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.FRONT, chunk, ref cellFace); Terrain.NormalQuad(v101, v100, v110, v111, cellFace.TextureSlot, cellFace.Color); } neighbor = chunk.GetCellContent(x, y + 1, z); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.TOP, chunk, ref cellFace); Terrain.NormalQuad(v011, v111, v110, v010, cellFace.TextureSlot, cellFace.Color); } neighbor = chunk.GetCellContent(x, y, z + 1); if (neighbor != BlockTerrain.NULL_BLOCK_CONTENT && BlocksData.IsTransparent[neighbor]) { block.GenerateTerrain(x, y, z, value, CellFace.RIGHT, chunk, ref cellFace); Terrain.NormalQuad(v001, v101, v111, v011, cellFace.TextureSlot, cellFace.Color); } } } } } }
public string ToString(int value) { return(string.Format("{0}: {1}, {2}", Name, Index, BlockTerrain.GetData(value))); }
public Color Lookup(int value) { return(Lookup(BlockTerrain.GetTemperature(value), BlockTerrain.GetHumidity(value))); }
public void GenerateFurnitureMeshAlphaTest(FurnitureManager.Furniture furniture, out MeshData mesh) { Block[] blocks = BlocksData.Blocks; int res = furniture.Resolution; Matrix4x4 matrix = Matrix4x4.Scale(Vector3.one / res); float uvBlockSize = 0.0625f / res; int[] mask = new int[res * res]; int u, v, n, w, h, j, i, l, k; int[] off; int[] x; for (int d = 0; d < 3; d++) { off = new int[] { 0, 0, 0 }; x = new int[] { 0, 0, 0 }; u = (d + 1) % 3; v = (d + 2) % 3; off[d] = 1; for (x[d] = -1; x[d] < res;) { //Debug.LogFormat("x[d]: {0}", x[d]); mask = new int[res * res]; for (n = 0; n < mask.Length; n++) { mask[n] = -1; } n = 0; for (x[v] = 0; x[v] < res; x[v]++) { for (x[u] = 0; x[u] < res; x[u]++) { int va = furniture.GetCellValue(x[0], x[1], x[2]); int vb = furniture.GetCellValue(x[0] + off[0], x[1] + off[1], x[2] + off[2]); int ia = BlockTerrain.GetContent(va); int ib = BlockTerrain.GetContent(vb); //Debug.LogFormat("{0} and {1}: {2}, {3}", new Point3(x[0], x[1], x[2]), new Point3(x[0] + off[0], x[1] + off[1], x[2] + off[2]), a.Name, b.Name); if (ia == 0 && ib != 0) { Block b = blocks[ib]; mask[n] = b.TextureSlot; mask[n] |= BlocksData.GetBlockColorInt(b, vb) << 8; mask[n] |= 4096; } else if (ia != 0 && ib == 0) { Block a = blocks[ia]; mask[n] = a.TextureSlot; mask[n] |= BlocksData.GetBlockColorInt(a, va) << 8; } n++; } } ++x[d]; n = 0; for (j = 0; j < res; j++) { for (i = 0; i < res;) { if (mask[n] != -1) { for (w = 1; i + w < res && mask[w + n] == mask[n]; w++) { } for (h = 1; h + j < res; h++) { for (k = 0; k < w; k++) { if (mask[n + k + h * res] != mask[n]) { goto Done; } } } Done: //Debug.LogFormat("quard: {0}, {1}, {2}, {3}; {4}", j, i, h, w, x[d]); x[u] = i; x[v] = j; int[] du = new int[] { 0, 0, 0 }; int[] dv = new int[] { 0, 0, 0 }; du[u] = w; dv[v] = h; int textureSlot = mask[n] & 255; if (mask[n] >> 12 == 0) { Terrain.FurnitureQuad( new Vector3(x[0], x[1], x[2]), new Vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]), new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]), new Vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]), x[u], x[v], w, h, uvBlockSize, textureSlot, BlocksData.DEFAULT_COLORS[(mask[n] >> 8) & 15] ); } else { Terrain.FurnitureQuad( new Vector3(x[0], x[1], x[2]), new Vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]), new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]), new Vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]), x[v], x[u], h, w, uvBlockSize, textureSlot, BlocksData.DEFAULT_COLORS[(mask[n] >> 8) & 15] ); } for (l = 0; l < h; l++) { for (k = 0; k < w; k++) { mask[n + k + l * res] = -1; } } i += w; n += w; } else { i++; n++; } } } } } //Debug.LogFormat("{0}, {1}, {2}", vertices.Count, colors.Count, uvs.Count); Terrain.PushToMesh(out mesh); MeshData.Transform(mesh, matrix); }
public void GenerateChunkMesh(BlockTerrain.Chunk chunk) { bool[] isTrans = BlocksData.IsTransparent; IStandardCubeBlock[] blocks = BlocksData.StandardCubeBlocks; CellFace[] mask; int u, v, n, w, h, j, i, l, k; int[] off; int[] x; int[] dim = new int[] { 16, 128, 16 }; for (int d = 0; d < 3; d++) { off = new int[] { 0, 0, 0 }; x = new int[] { 0, 0, 0 }; u = (d + 1) % 3; v = (d + 2) % 3; off[d] = 1; //face = d; mask = new CellFace[dim[u] * dim[v]]; for (x[d] = -1; x[d] < dim[d];) { //Debug.LogFormat("x[d]: {0}", x[d]); for (n = 0; n < mask.Length; n++) { mask[n].TextureSlot = -1; } n = 0; for (x[v] = 0; x[v] < dim[v]; x[v]++) { for (x[u] = 0; x[u] < dim[u]; x[u]++) { int va = chunk.GetCellValue(x[0], x[1], x[2]); int vb = chunk.GetCellValue(x[0] + off[0], x[1] + off[1], x[2] + off[2]); if (va == BlockTerrain.NULL_BLOCK_VALUE || vb == BlockTerrain.NULL_BLOCK_VALUE) { break; } int ca = BlockTerrain.GetContent(va); int cb = BlockTerrain.GetContent(vb); //Debug.LogFormat("{0} and {1}: {2}, {3}", new Point3(x[0], x[1], x[2]), new Point3(x[0] + off[0], x[1] + off[1], x[2] + off[2]), a.Name, b.Name); if (isTrans[ca]) { if (!isTrans[cb] && (((x[0] + off[0])) & 16) == 0) { mask[n].IsOpposite = true; blocks[cb].GenerateTerrain(x[0] + off[0], x[1] + off[1], x[2] + off[2], vb, CellFace.opposite[d], chunk, ref mask[n]); } } else { if (isTrans[cb]) { mask[n].IsOpposite = false; blocks[ca].GenerateTerrain(x[0], x[1], x[2], va, d, chunk, ref mask[n]); } } n++; } } ++x[d]; n = 0; for (j = 0; j < dim[v]; j++) { for (i = 0; i < dim[u];) { if (mask[n].TextureSlot != -1) { for (w = 1; i + w < dim[u] && mask[w + n] == mask[n]; w++) { } for (h = 1; h + j < dim[v]; h++) { for (k = 0; k < w; k++) { if (mask[n + k + h * dim[u]] != mask[n]) { goto Done; } } } Done: //Debug.LogFormat("quard: {0}, {1}, {2}, {3}; {4}", j, i, h, w, x[d]); x[u] = i; x[v] = j; int[] du = new int[] { 0, 0, 0 }; int[] dv = new int[] { 0, 0, 0 }; du[u] = w; dv[v] = h; int textureSlot = mask[n].TextureSlot; if (!mask[n].IsOpposite) { Terrain.Quad( new Vector3(x[0], x[1], x[2]), new Vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]), new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]), new Vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]), textureSlot, mask[n].Color ); } else { Terrain.Quad( new Vector3(x[0], x[1], x[2]), new Vector3(x[0] + dv[0], x[1] + dv[1], x[2] + dv[2]), new Vector3(x[0] + du[0] + dv[0], x[1] + du[1] + dv[1], x[2] + du[2] + dv[2]), new Vector3(x[0] + du[0], x[1] + du[1], x[2] + du[2]), textureSlot, mask[n].Color ); } for (l = 0; l < h; l++) { for (k = 0; k < w; k++) { mask[n + k + l * dim[u]].TextureSlot = -1; } } i += w; n += w; } else { i++; n++; } } } } } }