public void OnAfterDeserialize()
{
#region repair
if (weightKeys.Count < weightValues.Count)
{
weightValues.RemoveRange(weightKeys.Count, weightValues.Count - weightKeys.Count);
}
else if (weightKeys.Count > weightValues.Count)
{
weightKeys.RemoveRange(weightValues.Count, weightKeys.Count - weightValues.Count);
}
#endregion
{
IntVector3 max = IntVector3.zero;
for (int i = 0; i < weightKeys.Count; i++)
{
max = IntVector3.Max(max, weightKeys[i]);
}
indexTable = new DataTable3 <int>(max.x, max.y, max.z);
}
for (int i = 0; i < weightKeys.Count; i++)
{
if (indexTable.Contains(weightKeys[i]))
{
weightKeys.RemoveAt(i);
weightValues.RemoveAt(i);
i--;
continue;
}
indexTable.Set(weightKeys[i], i);
}
}
private void CheckFillVoxelTableCheck()
{
if (fillVoxelDataLastTimeTicks != objectTarget.voxelData.updateVoxelTableLastTimeTicks)
{
fillVoxelTable = null;
fillVoxelFaceAreaTable = null;
fillVoxelDataLastTimeTicks = objectTarget.voxelData.updateVoxelTableLastTimeTicks;
}
}
public void ClearCache()
{
ClearSilhouetteMeshMesh();
ClearPreviewMesh();
ClearCursorMesh();
fillVoxelTable = null;
fillVoxelFaceAreaTable = null;
fillVoxelFaceTable = null;
fillVoxelFaceFaceAreaTable = null;
}
public void CreateMaterialIndexTable()
{
materialIndexTable = null;
if (voxelData == null || materialData == null) return;
materialIndexTable = new DataTable3<int>(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
for (int i = 1; i < materialData.Count; i++)
{
materialData[i].AllAction((pos) =>
{
materialIndexTable.Set(pos, i);
});
}
}
public void OnAfterDeserialize()
{
IntVector3 max = IntVector3.zero;
for (int i = 0; i < disableList.Count; i++)
{
max = IntVector3.Max(max, disableList[i]);
}
indexTable = new DataTable3 <VoxelBase.Face>(max.x + 1, max.y + 1, max.z + 1);
for (int i = 0; i < disableList.Count; i++)
{
indexTable.Set(disableList[i], faceList[i]);
}
}
public void OnAfterDeserialize()
{
IntVector3 max = IntVector3.zero;
for (int i = 0; i < materialList.Count; i++)
{
max = IntVector3.Max(max, materialList[i]);
}
indexTable = new DataTable3 <int>(max.x + 1, max.y + 1, max.z + 1);
for (int i = 0; i < materialList.Count; i++)
{
indexTable.Set(materialList[i], i);
}
}
public void CreateVoxelTable()
{
#region voxelTable
{
voxelTable = new DataTable3 <int>(voxelSize.x, voxelSize.y, voxelSize.z);
if (voxels != null)
{
for (int i = 0; i < voxels.Length; i++)
{
voxelTable.Set(voxels[i].position, i);
}
}
}
#endregion
#region vertexList
{
vertexList = new List <IntVector3>();
bool[,,] doneTable = new bool[voxelSize.x + 1, voxelSize.y + 1, voxelSize.z + 1];
Action <IntVector3> AddPoint = (pos) =>
{
if (pos.x < 0 || pos.y < 0 || pos.z < 0)
{
return;
}
if (!doneTable[pos.x, pos.y, pos.z])
{
doneTable[pos.x, pos.y, pos.z] = true;
vertexList.Add(pos);
}
};
if (voxels != null)
{
for (int i = 0; i < voxels.Length; i++)
{
AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z + 1));
}
}
}
#endregion
}
public VoxelData.FaceAreaTable GetFillVoxelFaceAreaTable(IntVector3 pos)
{
if (objectTarget.voxelData == null)
{
return(null);
}
if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
{
return(null);
}
CheckFillVoxelTableCheck();
if (fillVoxelFaceAreaTable == null)
{
fillVoxelFaceAreaTable = new DataTable3 <VoxelData.FaceAreaTable>(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
}
if (!fillVoxelFaceAreaTable.Contains(pos))
{
var list = GetFillVoxel(pos);
if (list == null)
{
return(null);
}
var voxels = new List <VoxelData.Voxel>();
for (int i = 0; i < list.Count; i++)
{
var index = objectTarget.voxelData.VoxelTableContains(list[i]);
var voxel = objectTarget.voxelData.voxels[index];
voxel.palette = -1;
voxels.Add(voxel);
}
var faceAreaTable = objectCore.Edit_CreateMeshOnly_FaceArea(voxels, true);
for (int i = 0; i < list.Count; i++)
{
fillVoxelFaceAreaTable.Set(list[i], faceAreaTable);
}
}
var fillVoxelFaceArea = fillVoxelFaceAreaTable.Get(pos);
return(fillVoxelFaceArea);
}
public void CreateVoxelTable()
{
#region voxelTable
{
voxelTable = new DataTable3 <int>(voxelSize.x, voxelSize.y, voxelSize.z);
if (voxels != null)
{
for (int i = 0; i < voxels.Length; i++)
{
voxelTable.Set(voxels[i].position, i);
}
}
}
#endregion
#region vertexList
{
vertexList = new List <IntVector3>(2 * voxels.Length);
bool[,,] doneTable = new bool[voxelSize.x + 1, voxelSize.y + 1, voxelSize.z + 1];
Action <IntVector3> AddPoint = (pos) =>
{
if (pos.x < 0 || pos.y < 0 || pos.z < 0)
{
return;
}
if (!doneTable[pos.x, pos.y, pos.z])
{
doneTable[pos.x, pos.y, pos.z] = true;
vertexList.Add(pos);
}
};
if (voxels != null)
{
for (int i = 0; i < voxels.Length; i++)
{
AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x, voxels[i].y + 1, voxels[i].z + 1));
AddPoint(new IntVector3(voxels[i].x + 1, voxels[i].y + 1, voxels[i].z + 1));
}
}
}
#endregion
#region outsideTable
{
bool[,,] doneTable = new bool[voxelSize.x, voxelSize.y, voxelSize.z];
outsideTable = new FlagTable3(voxelSize.x, voxelSize.y, voxelSize.z);
List <IntVector3> findList = new List <IntVector3>(voxelSize.x * voxelSize.y * voxelSize.z);
Action <int, int, int> AddFindList = (x, y, z) =>
{
if (x < 0 || x >= voxelSize.x || y < 0 || y >= voxelSize.y || z < 0 || z >= voxelSize.z)
{
return;
}
if (doneTable[x, y, z])
{
return;
}
doneTable[x, y, z] = true;
if (VoxelTableContains(x, y, z) >= 0)
{
return;
}
if (outsideTable.Get(x, y, z))
{
return;
}
findList.Add(new IntVector3(x, y, z));
outsideTable.Set(x, y, z, true);
};
for (int x = 0; x < voxelSize.x; x++)
{
for (int y = 0; y < voxelSize.y; y++)
{
AddFindList(x, y, 0);
AddFindList(x, y, voxelSize.z - 1);
}
for (int z = 0; z < voxelSize.z; z++)
{
AddFindList(x, 0, z);
AddFindList(x, voxelSize.y - 1, z);
}
}
for (int z = 0; z < voxelSize.z; z++)
{
for (int y = 0; y < voxelSize.y; y++)
{
AddFindList(0, y, z);
AddFindList(voxelSize.x - 1, y, z);
}
}
for (int i = 0; i < findList.Count; i++)
{
var pos = findList[i];
AddFindList(pos.x + 1, pos.y, pos.z);
AddFindList(pos.x - 1, pos.y, pos.z);
AddFindList(pos.x, pos.y + 1, pos.z);
AddFindList(pos.x, pos.y - 1, pos.z);
AddFindList(pos.x, pos.y, pos.z + 1);
AddFindList(pos.x, pos.y, pos.z - 1);
}
}
#endregion
updateVoxelTableLastTimeTicks = DateTime.Now.Ticks;
}
protected override void CreateChunkData()
{
if (voxelObject.splitMode != VoxelChunksObject.SplitMode.ChunkSize)
{
if (voxelData.chunkDataList == null)
{
voxelObject.splitMode = VoxelChunksObject.SplitMode.ChunkSize;
}
}
if (voxelObject.splitMode == VoxelChunksObject.SplitMode.QubicleMatrix || voxelObject.splitMode == VoxelChunksObject.SplitMode.WorldEditor)
{
voxelData.chunkTable = new DataTable3 <IntVector3>(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
var chunkVoxels = new List <int> [voxelData.chunkDataList.Count];
var chunkPalettes = new HashSet <Color> [voxelData.chunkDataList.Count];
for (int i = 0; i < voxelData.chunkDataList.Count; i++)
{
chunkVoxels[i] = new List <int>();
chunkPalettes[i] = new HashSet <Color>();
}
for (int i = 0; i < voxelData.voxels.Length; i++)
{
var chunkIndex = voxelData.chunkIndexTable.Get(voxelData.voxels[i].position);
//voxel
chunkVoxels[chunkIndex].Add(i);
//palette
chunkPalettes[chunkIndex].Add(voxelData.palettes[voxelData.voxels[i].palette]);
//
voxelData.chunkTable.Set(voxelData.voxels[i].position, new IntVector3(chunkIndex, int.MinValue, int.MinValue));
}
{
chunkDataList = new List <ChunkData>(chunkVoxels.Length);
for (int i = 0; i < chunkVoxels.Length; i++)
{
chunkDataList.Add(new ChunkData()
{
position = new IntVector3(i, int.MinValue, int.MinValue),
name = string.Format("Chunk({0})", voxelData.chunkDataList[i].name),
area = voxelData.chunkDataList[i].area,
voxels = chunkVoxels[i],
palettes = chunkPalettes[i].ToArray()
});
}
chunkDataList.Sort((a, b) => string.Compare(voxelData.chunkDataList[a.position.x].name, voxelData.chunkDataList[b.position.x].name));
}
}
else
{
voxelData.chunkTable = new DataTable3 <IntVector3>(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
var chunkVoxels = new DataTable3 <List <int> >(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
var chunkPalettes = new DataTable3 <HashSet <Color> >(voxelData.voxelSize.x, voxelData.voxelSize.y, voxelData.voxelSize.z);
for (int i = 0; i < voxelData.voxels.Length; i++)
{
var chunkPosition = GetChunkPosition(voxelData.voxels[i].position);
//voxel
if (!chunkVoxels.Contains(chunkPosition))
{
chunkVoxels.Set(chunkPosition, new List <int>());
}
chunkVoxels.Get(chunkPosition).Add(i);
//palette
if (!chunkPalettes.Contains(chunkPosition))
{
chunkPalettes.Set(chunkPosition, new HashSet <Color>());
}
chunkPalettes.Get(chunkPosition).Add(voxelData.palettes[voxelData.voxels[i].palette]);
//
voxelData.chunkTable.Set(voxelData.voxels[i].position, chunkPosition);
}
{
chunkDataList = new List <ChunkData>();
chunkVoxels.AllAction((x, y, z, list) =>
{
var pos = new IntVector3(x, y, z);
chunkDataList.Add(new ChunkData()
{
position = pos,
name = string.Format("Chunk({0}, {1}, {2})", x, y, z),
area = new VoxelData.ChunkArea()
{
min = pos * voxelObject.chunkSize, max = (pos + IntVector3.one) * voxelObject.chunkSize - IntVector3.one
},
voxels = list,
palettes = chunkPalettes.Get(pos).ToArray()
});
});
chunkDataList.Sort((a, b) => a.position.x != b.position.x ? a.position.x - b.position.x : a.position.y != b.position.y ? a.position.y - b.position.y : a.position.z - b.position.z);
}
}
}
public List <IntVector3> GetFillVoxel(IntVector3 pos)
{
if (objectTarget.voxelData == null)
{
return(null);
}
if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
{
return(null);
}
if (fillVoxelTable == null)
{
fillVoxelTable = new DataTable3 <List <IntVector3> >(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
}
if (!fillVoxelTable.Contains(pos))
{
List <IntVector3> searchList = new List <IntVector3>();
for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
{
int posPalette = 0;
var doneTable = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
{
var p = objectTarget.voxelData.voxels[i].position;
if (fillVoxelTable.Get(p) != null)
{
continue;
}
var index = objectTarget.voxelData.VoxelTableContains(p);
posPalette = objectTarget.voxelData.voxels[index].palette;
searchList.Clear();
searchList.Add(p);
doneTable.Set(p, true);
}
var result = new List <IntVector3>();
for (int j = 0; j < searchList.Count; j++)
{
var p = searchList[j];
var index = objectTarget.voxelData.VoxelTableContains(p);
if (index < 0)
{
continue;
}
if (objectTarget.voxelData.voxels[index].palette == posPalette)
{
result.Add(p);
for (int x = p.x - 1; x <= p.x + 1; x++)
{
for (int y = p.y - 1; y <= p.y + 1; y++)
{
for (int z = p.z - 1; z <= p.z + 1; z++)
{
if (x >= 0 && y >= 0 && z >= 0 &&
x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
!doneTable.Get(x, y, z))
{
doneTable.Set(x, y, z, true);
var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
if (indexTmp >= 0 && objectTarget.voxelData.voxels[indexTmp].palette == posPalette)
{
searchList.Add(new IntVector3(x, y, z));
}
}
}
}
}
}
}
for (int j = 0; j < result.Count; j++)
{
fillVoxelTable.Set(result[j], result);
}
}
}
var fillVoxel = fillVoxelTable.Get(pos);
return(fillVoxel);
}
public VoxelData.FaceAreaTable GetFillVoxelFaceFaceAreaTable(IntVector3 pos, VoxelBase.Face face)
{
if (objectTarget.voxelData == null)
{
return(null);
}
if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
{
return(null);
}
CheckFillVoxelTableCheck();
if (fillVoxelFaceFaceAreaTable == null)
{
fillVoxelFaceFaceAreaTable = new DataTable3 <Dictionary <int, VoxelData.FaceAreaTable> >(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
}
if (!fillVoxelFaceFaceAreaTable.Contains(pos) ||
!fillVoxelFaceFaceAreaTable.Get(pos).ContainsKey((int)face))
{
var list = GetFillVoxelFace(pos, face);
if (list == null)
{
return(null);
}
var voxels = new List <VoxelData.Voxel>();
for (int i = 0; i < list.Count; i++)
{
var index = objectTarget.voxelData.VoxelTableContains(list[i]);
var voxel = objectTarget.voxelData.voxels[index];
voxel.palette = -1;
voxel.visible = face;
voxels.Add(voxel);
}
var faceAreaTable = objectCore.Edit_CreateMeshOnly_FaceArea(voxels, true);
Dictionary <int, VoxelData.FaceAreaTable> data;
if (fillVoxelFaceFaceAreaTable.Contains(pos))
{
data = fillVoxelFaceFaceAreaTable.Get(pos);
}
else
{
data = new Dictionary <int, VoxelData.FaceAreaTable>();
}
data[(int)face] = faceAreaTable;
fillVoxelFaceFaceAreaTable.Set(pos, data);
for (int i = 0; i < list.Count; i++)
{
if (fillVoxelFaceFaceAreaTable.Contains(list[i]))
{
data = fillVoxelFaceFaceAreaTable.Get(list[i]);
}
else
{
data = new Dictionary <int, VoxelData.FaceAreaTable>();
}
data[(int)face] = faceAreaTable;
fillVoxelFaceFaceAreaTable.Set(list[i], data);
}
}
var fillVoxelFaceArea = fillVoxelFaceFaceAreaTable.Get(pos)[(int)face];
return(fillVoxelFaceArea);
}
public List <IntVector3> GetFillVoxelFace(IntVector3 pos, VoxelBase.Face face)
{
if (objectTarget.voxelData == null)
{
return(null);
}
if (objectTarget.voxelData.VoxelTableContains(pos) < 0)
{
return(null);
}
CheckFillVoxelTableCheck();
if (fillVoxelFaceTable == null)
{
fillVoxelFaceTable = new DataTable3 <Dictionary <int, List <IntVector3> > >(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
}
if (!fillVoxelFaceTable.Contains(pos) ||
!fillVoxelFaceTable.Get(pos).ContainsKey((int)face))
{
List <IntVector3> searchList = new List <IntVector3>();
var doneTable = new FlagTable3(objectTarget.voxelData.voxelSize.x, objectTarget.voxelData.voxelSize.y, objectTarget.voxelData.voxelSize.z);
{
searchList.Clear();
searchList.Add(pos);
doneTable.Set(pos, true);
}
var result = new List <IntVector3>();
for (int j = 0; j < searchList.Count; j++)
{
var p = searchList[j];
var index = objectTarget.voxelData.VoxelTableContains(p);
if (index < 0)
{
continue;
}
if ((objectTarget.voxelData.voxels[index].visible & face) != 0)
{
result.Add(p);
int xOffset = (face & (VoxelBase.Face.up | VoxelBase.Face.down | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
int yOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.forward | VoxelBase.Face.back)) != 0 ? 1 : 0;
int zOffset = (face & (VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.up | VoxelBase.Face.down)) != 0 ? 1 : 0;
for (int x = p.x - xOffset; x <= p.x + xOffset; x++)
{
for (int y = p.y - yOffset; y <= p.y + yOffset; y++)
{
for (int z = p.z - zOffset; z <= p.z + zOffset; z++)
{
if (x >= 0 && y >= 0 && z >= 0 &&
x < objectTarget.voxelData.voxelSize.x && y < objectTarget.voxelData.voxelSize.y && z < objectTarget.voxelData.voxelSize.z &&
!doneTable.Get(x, y, z))
{
doneTable.Set(x, y, z, true);
var indexTmp = objectTarget.voxelData.VoxelTableContains(x, y, z);
if (indexTmp >= 0)
{
searchList.Add(new IntVector3(x, y, z));
}
}
}
}
}
}
}
Dictionary <int, List <IntVector3> > data;
if (fillVoxelFaceTable.Contains(pos))
{
data = fillVoxelFaceTable.Get(pos);
}
else
{
data = new Dictionary <int, List <IntVector3> >();
}
data[(int)face] = result;
fillVoxelFaceTable.Set(pos, data);
for (int j = 0; j < result.Count; j++)
{
if (fillVoxelFaceTable.Contains(result[j]))
{
data = fillVoxelFaceTable.Get(result[j]);
}
else
{
data = new Dictionary <int, List <IntVector3> >();
}
data[(int)face] = result;
fillVoxelFaceTable.Set(result[j], data);
}
}
var fillVoxel = fillVoxelFaceTable.Get(pos)[(int)face];
return(fillVoxel);
}
