public void UpgradeFromData(VoxelData data, int sz, int offsetX, int offsetZ)
{
size = sz;
nodes = new VoxelOctNode[data.sizeY/size+1];
for (int i=0; i<nodes.Length; i++) nodes[i] = new VoxelOctNode();
for (int y=0; y<data.sizeY; y++)
for (int x=0; x<size; x++)
for (int z=0; z<size; z++)
{
VoxelOctNode node = data.GetClosestNode(x+offsetX, y, z+offsetZ);
SetBlock(x,y,z, node.type, node.exists);
}
}
public void Resize( int newX , int newY , int newZ , int newNode )
{
int nX= Mathf.CeilToInt(1.0f*newX/newNode);
int nY= Mathf.CeilToInt(1.0f*newY/newNode);
int nZ= Mathf.CeilToInt(1.0f*newZ/newNode);
VoxelOctNode[] newOctree= new VoxelOctNode[ nX * nY * nZ ];
for (int x=0; x<nX; x++)
for (int y=0; y<nY; y++)
for (int z=0; z<nZ; z++)
{
int i = z*nY*nX + y*nX + x;
newOctree[i] = new VoxelOctNode();
//newOctree[i].GenerateFromOctree(this, x*newNode, y*newNode, z*newNode, newNode/2, 0,0,0);
}
octree = newOctree;
sizeX = newX; sizeY = newY; sizeZ = newZ;
biggestNode = newNode;
nodesX = nX; nodesY = nY; nodesZ = nZ;
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
public void Offset( int stepX , int stepY , int stepZ )
{
VoxelOctNode[] newOctree= new VoxelOctNode[ nodesX * nodesY * nodesZ ];
for (int x=0; x<nodesX; x++)
for (int y=0; y<nodesY; y++)
for (int z=0; z<nodesZ; z++)
{
int i = z*nodesY*nodesX + y*nodesX + x;
newOctree[i] = new VoxelOctNode();
//newOctree[i].GenerateFromOctree(this, x*biggestNode, y*biggestNode, z*biggestNode, biggestNode/2, -stepX, -stepY, -stepZ);
}
octree = newOctree;
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
public void LoadFromText(string from, bool[] existsArray)
{
#if UNITY_EDITOR
if(!System.IO.File.Exists(from)) return;
System.IO.StreamReader reader= System.IO.File.OpenText(from);
//calc exists array
nodesX = System.Int32.Parse(reader.ReadLine());
nodesY = System.Int32.Parse(reader.ReadLine());
nodesZ = System.Int32.Parse(reader.ReadLine());
biggestNode = System.Int32.Parse(reader.ReadLine());
sizeX = nodesX*biggestNode;
sizeY = nodesY*biggestNode;
sizeZ = nodesZ*biggestNode;
newSizeX = sizeX;
newSizeY = sizeY;
newSizeZ = sizeZ;
newBiggestNode = biggestNode;
octree = new VoxelOctNode[ nodesX * nodesY * nodesZ ];
//for (int x=0; x<nodesX; x++)
// for (int y=0; y<nodesY; y++)
// for (int z=0; z<nodesZ; z++)
for (int i=0; i<octree.Length; i++)
{
//int i = z*nodesY*nodesX + y*nodesX + x;
octree[i] = new VoxelOctNode();
System.Collections.Generic.List<int> nodeIntList = new System.Collections.Generic.List<int>();
string nodeListString = reader.ReadLine();
for (int c=0; c<nodeListString.Length; c++) nodeIntList.Add( int.Parse(nodeListString[c].ToString())-1 );
octree[i].LoadFromIntList(nodeIntList, existsArray);
}
reader.Close();
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
//returns the deepest node at given coords
public VoxelOctNode SetNode(int x, int y , int z, int halfsize)
{
//returning the deepest node
if (halfsize == 0) return this;
//dividing nodes if no nodes exist
if (nodes==null || nodes.Length==0)
{
nodes = new VoxelOctNode[8];
for (int i=0;i<8;i++)
{
nodes[i] = new VoxelOctNode();
nodes[i].exists = exists;
nodes[i].type = type;
}
}
//setting node recursively
if (x<halfsize)
{
if (y<halfsize)
{
if (z<halfsize) return nodes[0].SetNode(x,y,z,halfsize/2);
else return nodes[1].SetNode(x,y,z-halfsize,halfsize/2);
}
else
{
if (z<halfsize) return nodes[2].SetNode(x,y-halfsize,z,halfsize/2);
else return nodes[3].SetNode(x,y-halfsize,z-halfsize,halfsize/2);
}
}
else
{
if (y<halfsize)
{
if (z<halfsize) return nodes[4].SetNode(x-halfsize,y,z,halfsize/2);
else return nodes[5].SetNode(x-halfsize,y,z-halfsize,halfsize/2);
}
else
{
if (z<halfsize) return nodes[6].SetNode(x-halfsize,y-halfsize,z,halfsize/2);
else return nodes[7].SetNode(x-halfsize,y-halfsize,z-halfsize,halfsize/2);
}
}
}
public void LoadFromIntList(System.Collections.Generic.List<int> list, bool[] arrayOfTypes)
{
if (list[0] != -1) //if solid node
{
type = list[0];
exists = arrayOfTypes[type];
list.RemoveAt(0);
}
else
{
list.RemoveAt(0);
nodes = new VoxelOctNode[8];
for (int n=0;n<8;n++)
{
nodes[n] = new VoxelOctNode();
nodes[n].LoadFromIntList(list, arrayOfTypes);
}
}
}
public VoxelOctNode Copy()
{
VoxelOctNode result = new VoxelOctNode();
result.exists = exists;
result.type = type;
if (nodes!=null && nodes.Length!=0)
{
result.nodes = new VoxelOctNode[8];
for (int n=0; n<8; n++) result.nodes[n] = nodes[n].Copy();
}
return result;
}
public void SetHeightmap( float[,] map1, float[,] map2, float[,] map3, float[,] map4,
int type1, int type2, int type3, int type4,
int height, int nodeSize)
{
nodesX = Mathf.CeilToInt(1.0f*map1.GetLength(0)/nodeSize);
nodesY = Mathf.CeilToInt(1.0f*height/nodeSize);
nodesZ = Mathf.CeilToInt(1.0f*map1.GetLength(1)/nodeSize);
octree = new VoxelOctNode[ nodesX * nodesY * nodesZ ];
for (int x=0; x<nodesX; x++)
for (int y=0; y<nodesY; y++)
for (int z=0; z<nodesZ; z++)
{
int i = z*nodesY*nodesX + y*nodesX + x;
octree[i] = new VoxelOctNode();
//octree[i].GenerateFromHeightmap( map1, map2, map3, map4, type1, type2, type3, type4,
// x*nodeSize, y*nodeSize, z*nodeSize, nodeSize/2); //offsets
}
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
