/// <summary>
/// Set from WorldCubePositon
/// </summary>
/// <param name="coordinate"></param>
/// <param name="data"></param>
public void SetCubeData(CubeCoordinate coordinate, byte data, bool refersh = false)
{
int index = CubeMetrics.GetCubeIndex_FromWorldToLocal(coordinate.x, coordinate.y, coordinate.z,
chunkX, chunkY, chunkZ);
SetCubeData(index, data, refersh);
}
public byte GetCubeData(CubeCoordinate coordinate)
{
int index = CubeMetrics.GetCubeIndex_FromWorldToLocal(coordinate.x, coordinate.y, coordinate.z,
chunkX, chunkY, chunkZ);
return(GetCubeData(index));
}
Vector3[] GetCubeVertices(Vector3 position, CubeOrientate orientate)
{
for (int i = 0; i < tempVerticesArray.Length; i++)
{
tempVerticesArray[i] = transform.InverseTransformPoint(position + CubeMetrics.GetCubeVertexByOrientate(i, orientate));
}
return(tempVerticesArray);
}
public void SetCubeData(Vector3 position, byte data)
{
Vector3 cubePosition = CubeMetrics.WorldPosition2CubePosition(position);
CubeCoordinate chunkCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.chunk);
CubeCoordinate cubeCoordinate = new CubeCoordinate(position, CubeCoordinate.CoordinateType.cubeWorld);
CubeChunk chunk = chunks[chunkCoordinate.ToString()];
chunk.SetCubeData(cubePosition, data, true);
}
void CenterUpdata()
{
Bounds b = new Bounds(M_centerPoint, CurBoundSize);
Bounds b2 = new Bounds(curMaxBoundsCenter, MaxBoundSize);
if (b2.Contains(b.max) && b2.Contains(b.min))
{
return;
}
curMaxBoundsCenter = CubeMetrics.WorldPositon2ChunkPosition(M_centerPoint);
manager.RefreshByBounds(new Bounds(curMaxBoundsCenter, MaxBoundSize));
}
public bool GetMouseRayPoint(Ray ray, out Vector3 addCubePosition, out Vector3 removeCubePosition)
{
Debug.DrawRay(ray.origin, ray.direction, Color.gray);
if (Physics.Raycast(ray, out RaycastHit hitInfo))
{
Debug.DrawLine(ray.origin, hitInfo.point, Color.red);
Debug.Log(hitInfo.transform.name);
addCubePosition = CubeMetrics.WorldPosition2CubePosition(hitInfo.point - ray.direction * 0.001f);
removeCubePosition = CubeMetrics.WorldPosition2CubePosition(hitInfo.point + ray.direction * 0.001f);
return(true);
}
addCubePosition = Vector3.zero;
removeCubePosition = Vector3.zero;
return(false);
}
public void SetCubeData(Vector3 cubePosition, byte data, bool refresh = false)
{
Vector3 p = CubeMetrics.WorldPosition2CubePosition(cubePosition);
SetCubeData(new CubeCoordinate(p, CubeCoordinate.CoordinateType.cubeWorld), data, refresh);
}
public void GeneratorTerrain()
{
cubes = CubeMetrics.GetTerrainData(this);
}
bool CheckAdjacent(int x, int y, int z, CubeSurface surfaceTo)
{
int minValue = 0;
int maxValue = CubeMetrics.CHUNK_WIDTH - 1;
switch (surfaceTo)
{
case CubeSurface.front:
if (z + 2 > CubeMetrics.CHUNK_WIDTH)
{
return(NeighborChunks[(int)AdjacentDirection.front] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.front].
cubes[CubeMetrics.GetCubeIndexToChunk(x, y, minValue)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y, z + 1)]).HasCube);
case CubeSurface.back:
if (z - 1 < 0)
{
return(NeighborChunks[(int)AdjacentDirection.back] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.back].
cubes[CubeMetrics.GetCubeIndexToChunk(x, y, maxValue)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y, z - 1)]).HasCube);
case CubeSurface.left:
if (x - 1 < 0)
{
return(NeighborChunks[(int)AdjacentDirection.left] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.left].cubes[CubeMetrics.GetCubeIndexToChunk(maxValue, y, z)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x - 1, y, z)]).HasCube);
case CubeSurface.right:
if (x + 2 > CubeMetrics.CHUNK_WIDTH)
{
return(NeighborChunks[(int)AdjacentDirection.right] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.right].cubes[CubeMetrics.GetCubeIndexToChunk(minValue, y, z)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x + 1, y, z)]).HasCube);
case CubeSurface.up:
if (y + 2 > CubeMetrics.CHUNK_WIDTH)
{
return(NeighborChunks[(int)AdjacentDirection.up] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.up].cubes[CubeMetrics.GetCubeIndexToChunk(x, minValue, z)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y + 1, z)]).HasCube);
case CubeSurface.down:
if (y - 1 < 0)
{
return(NeighborChunks[(int)AdjacentDirection.down] &&
CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.down].cubes[CubeMetrics.GetCubeIndexToChunk(x, maxValue, z)]).HasCube);
}
return(CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y - 1, z)]).HasCube);
default:
return(false);
}
}
public int GetCubeData(int x, int y, int z)
{
return(cubes[CubeMetrics.GetCubeIndexToChunk(x, y, z)]);
}
public byte GetCubeData(Vector3 cubePosition)
{
Vector3 p = CubeMetrics.WorldPosition2CubePosition(cubePosition);
return(GetCubeData(new CubeCoordinate(p, CubeCoordinate.CoordinateType.cubeWorld)));
}
/// <summary>
/// Set from localCubePosition
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <param name="data"></param>
public void SetCubeData(int x, int y, int z, byte data, bool refresh = false)
{
SetCubeData(CubeMetrics.GetCubeIndexToChunk(x, y, z), data, refresh);
}
void Start()
{
curMaxBoundsCenter = CubeMetrics.WorldPositon2ChunkPosition(M_centerPoint);
manager.RefreshByBounds(new Bounds(curMaxBoundsCenter, MaxBoundSize));
}
//
//bool CheckAdjacent2(int x, int y, int z, CubeSurface surfaceTo)
//{
// int minValue = 0;
// int maxValue = CubeMetrics.CHUNK_WIDTH - 1;
// CubeCoordinate c;
// switch (surfaceTo)
// {
// case CubeSurface.front:
// if (z + 2 > CubeMetrics.CHUNK_WIDTH)
// {
// c = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.front);
// //return grid.chunkDatas.ContainsKey(c.ToString()) &&
// // CubeData.ToCubeData(grid.chunkDatas[c.ToString()][CubeMetrics.GetCubeIndexToChunk(x, y, minValue)]).HasCube;
// //Debug.Log(grid.chunkDatas.ContainsKey(c.ToString()));
// return NeighborChunks[(int)AdjacentDirection.front] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.front].
// cubes[CubeMetrics.GetCubeIndexToChunk(x, y, minValue)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y, z + 1)]).HasCube;
// case CubeSurface.back:
// if (z - 1 < 0)
// {
// return NeighborChunks[(int)AdjacentDirection.back] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.back].
// cubes[CubeMetrics.GetCubeIndexToChunk(x, y, maxValue)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y, z - 1)]).HasCube;
// case CubeSurface.left:
// if (x - 1 < 0)
// {
// return NeighborChunks[(int)AdjacentDirection.left] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.left].cubes[CubeMetrics.GetCubeIndexToChunk(maxValue, y, z)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x - 1, y, z)]).HasCube;
// case CubeSurface.right:
// if (x + 2 > CubeMetrics.CHUNK_WIDTH)
// {
// return NeighborChunks[(int)AdjacentDirection.right] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.right].cubes[CubeMetrics.GetCubeIndexToChunk(minValue, y, z)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x + 1, y, z)]).HasCube;
// case CubeSurface.up:
// if (y + 2 > CubeMetrics.CHUNK_WIDTH)
// {
// return NeighborChunks[(int)AdjacentDirection.up] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.up].cubes[CubeMetrics.GetCubeIndexToChunk(x, minValue, z)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y + 1, z)]).HasCube;
// case CubeSurface.down:
// if (y - 1 < 0)
// {
// return NeighborChunks[(int)AdjacentDirection.down] &&
// CubeData.ToCubeData(NeighborChunks[(int)AdjacentDirection.down].cubes[CubeMetrics.GetCubeIndexToChunk(x, maxValue, z)]).HasCube;
// }
// return CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(x, y - 1, z)]).HasCube;
// default:
// return false;
// }
//}
//考虑未实例化到场景中的chunk, 直接在数据表里核对是否需要隐藏
bool CheckAdjacent(int x, int y, int z, CubeSurface surfaceTo, bool isTransparent)
{
int tempX = x;
int tempY = y;
int tempZ = z;
bool outOfRange = false;
CubeCoordinate coordinate;
switch (surfaceTo)
{
case CubeSurface.front:
outOfRange = z + 2 > CubeMetrics.CHUNK_WIDTH;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.front);
tempZ = outOfRange ? 0 : z + 1;
break;
case CubeSurface.back:
outOfRange = z - 1 < 0;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.back);
tempZ = outOfRange ? CubeMetrics.CHUNK_WIDTH - 1 : z - 1;
break;
case CubeSurface.left:
outOfRange = x - 1 < 0;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.left);
tempX = outOfRange ? CubeMetrics.CHUNK_WIDTH - 1 : x - 1;
break;
case CubeSurface.right:
outOfRange = x + 2 > CubeMetrics.CHUNK_WIDTH;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.right);
tempX = outOfRange ? 0 : x + 1;
break;
case CubeSurface.up:
outOfRange = y + 2 > CubeMetrics.CHUNK_WIDTH;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.up);
tempY = outOfRange ? 0 : y + 1;
break;
case CubeSurface.down:
outOfRange = y - 1 < 0;
coordinate = ChunkCoordinate.GetAdjacentCoordinate(AdjacentDirection.down);
tempY = outOfRange ? CubeMetrics.CHUNK_WIDTH - 1 : y - 1;
break;
default:
coordinate = ChunkCoordinate;
break;
}
try
{
return(outOfRange ?
grid.chunkDatas.ContainsKey(coordinate.ToString()) &&
CubeData.ToCubeData(grid.chunkDatas[coordinate.ToString()][CubeMetrics.GetCubeIndexToChunk(tempX, tempY, tempZ)]).HasCube(isTransparent) :
CubeData.ToCubeData(cubes[CubeMetrics.GetCubeIndexToChunk(tempX, tempY, tempZ)]).HasCube(isTransparent));
}
catch
{
Debug.Log("chunk" + ChunkCoordinate.ToString() + ":Surface" + surfaceTo + "index is error");
return(false);
}
}
