public virtual void Save()
{
voxelFilePath = controller.voxelFilePath;
voxelFileGUID = controller.voxelFileGUID;
voxelFileObject = controller.voxelFileObject;
voxelFileSubIndex = controller.voxelFileSubIndex;
legacyVoxImport = controller.legacyVoxImport;
importMode = controller.importMode;
importFlags = controller.importFlags;
importScale = controller.importScale;
importOffset = controller.importOffset;
enableFaceFlags = controller.enableFaceFlags;
generateLightmapUVs = controller.generateLightmapUVs;
meshFaceVertexOffset = controller.meshFaceVertexOffset;
generateMipMaps = controller.generateMipMaps;
if (controller.materialData != null)
{
materialData = new MaterialData[controller.materialData.Count];
for (int i = 0; i < controller.materialData.Count; i++)
{
if (controller.materialData[i] != null)
{
materialData[i] = controller.materialData[i].Clone();
}
}
}
else
{
materialData = null;
}
materialIndexes = controller.materialIndexes != null?controller.materialIndexes.ToArray() : null;
}
public Voxel(int x, int y, int z, int palette, VoxelBase.Face visible = VoxelBase.Face.forward | VoxelBase.Face.up | VoxelBase.Face.right | VoxelBase.Face.left | VoxelBase.Face.down | VoxelBase.Face.back)
{
this.x = x;
this.y = y;
this.z = z;
this.palette = palette;
this.visible = visible;
}
public void SetDisable(IntVector3 pos, VoxelBase.Face face)
{
if (!indexTable.Contains(pos))
{
indexTable.Set(pos, face);
disableList.Add(pos);
faceList.Add(face);
}
else
{
indexTable.Set(pos, face);
int index = disableList.IndexOf(pos);
faceList[index] = face;
}
}
public virtual void Save()
{
voxelFilePath = controller.voxelFilePath;
voxelFileGUID = controller.voxelFileGUID;
importMode = controller.importMode;
importFlags = controller.importFlags;
importScale = controller.importScale;
importOffset = controller.importOffset;
enableFaceFlags = controller.enableFaceFlags;
generateLightmapUVs = controller.generateLightmapUVs;
generateMipMaps = controller.generateMipMaps;
materialData = controller.materialData != null?controller.materialData.ToArray() : null;
materialIndexes = controller.materialIndexes != null?controller.materialIndexes.ToArray() : null;
}
protected override bool IsHiddenVoxelFace(IntVector3 basePos, VoxelBase.Face faceFlag)
{
if (voxelObject.createContactChunkFaces)
{
if (voxelChunkPositionTable == null)
{
CreateVoxelChunkPositionTable();
}
Assert.IsTrue(faceFlag == VoxelBase.Face.forward || faceFlag == VoxelBase.Face.up || faceFlag == VoxelBase.Face.right || faceFlag == VoxelBase.Face.left || faceFlag == VoxelBase.Face.down || faceFlag == VoxelBase.Face.back);
IntVector3 combinePos = basePos;
{
if (faceFlag == VoxelBase.Face.forward)
{
combinePos.z++;
}
if (faceFlag == VoxelBase.Face.up)
{
combinePos.y++;
}
if (faceFlag == VoxelBase.Face.right)
{
combinePos.x++;
}
if (faceFlag == VoxelBase.Face.left)
{
combinePos.x--;
}
if (faceFlag == VoxelBase.Face.down)
{
combinePos.y--;
}
if (faceFlag == VoxelBase.Face.back)
{
combinePos.z--;
}
}
return(voxelChunkPositionTable[basePos.x, basePos.y, basePos.z] == voxelChunkPositionTable[combinePos.x, combinePos.y, combinePos.z]);
}
else
{
return(base.IsHiddenVoxelFace(basePos, faceFlag));
}
}
protected override bool IsHiddenVoxelFace(IntVector3 basePos, VoxelBase.Face faceFlag)
{
if (voxelObject.createContactChunkFaces)
{
Assert.IsTrue(faceFlag == VoxelBase.Face.forward || faceFlag == VoxelBase.Face.up || faceFlag == VoxelBase.Face.right || faceFlag == VoxelBase.Face.left || faceFlag == VoxelBase.Face.down || faceFlag == VoxelBase.Face.back);
IntVector3 combinePos = basePos;
{
if (faceFlag == VoxelBase.Face.forward)
{
combinePos.z++;
}
if (faceFlag == VoxelBase.Face.up)
{
combinePos.y++;
}
if (faceFlag == VoxelBase.Face.right)
{
combinePos.x++;
}
if (faceFlag == VoxelBase.Face.left)
{
combinePos.x--;
}
if (faceFlag == VoxelBase.Face.down)
{
combinePos.y--;
}
if (faceFlag == VoxelBase.Face.back)
{
combinePos.z--;
}
}
return(voxelData.chunkTable.Get(basePos) == voxelData.chunkTable.Get(combinePos));
}
else
{
return(base.IsHiddenVoxelFace(basePos, faceFlag));
}
}
protected override bool IsCombineVoxelFace(IntVector3 basePos, IntVector3 combinePos, VoxelBase.Face face)
{
if (!base.IsCombineVoxelFace(basePos, combinePos, face))
{
return(false);
}
return(voxelData.chunkTable.Get(basePos) == voxelData.chunkTable.Get(combinePos));
}
protected override bool IsCombineVoxelFace(IntVector3 basePos, IntVector3 combinePos, VoxelBase.Face face)
{
var baseWeights = GetBoneWeightTable(basePos);
if (baseWeights == null)
{
return((GetBoneWeightTable(combinePos) == null) ? true : false);
}
else
{
var combineWeights = GetBoneWeightTable(combinePos);
if (combineWeights == null)
{
return(false);
}
Assert.IsTrue(baseWeights.Length == (int)VoxelBase.VoxelVertexIndex.Total && combineWeights.Length == (int)VoxelBase.VoxelVertexIndex.Total);
switch (face)
{
case VoxelBase.Face.forward:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ])
{
return(false);
}
break;
case VoxelBase.Face.up:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z])
{
return(false);
}
break;
case VoxelBase.Face.right:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z])
{
return(false);
}
break;
case VoxelBase.Face.left:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
break;
case VoxelBase.Face.down:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
break;
case VoxelBase.Face.back:
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] ||
baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
break;
default:
break;
}
return(true);
}
}
protected override bool IsHiddenVoxelFace(IntVector3 basePos, VoxelBase.Face faceFlag)
{
Assert.IsTrue(faceFlag == VoxelBase.Face.forward || faceFlag == VoxelBase.Face.up || faceFlag == VoxelBase.Face.right || faceFlag == VoxelBase.Face.left || faceFlag == VoxelBase.Face.down || faceFlag == VoxelBase.Face.back);
IntVector3 combinePos = basePos;
{
if (faceFlag == VoxelBase.Face.forward)
{
combinePos.z++;
}
if (faceFlag == VoxelBase.Face.up)
{
combinePos.y++;
}
if (faceFlag == VoxelBase.Face.right)
{
combinePos.x++;
}
if (faceFlag == VoxelBase.Face.left)
{
combinePos.x--;
}
if (faceFlag == VoxelBase.Face.down)
{
combinePos.y--;
}
if (faceFlag == VoxelBase.Face.back)
{
combinePos.z--;
}
}
var baseWeights = GetBoneWeightTable(basePos);
var combineWeights = GetBoneWeightTable(combinePos);
if (baseWeights == null && combineWeights == null)
{
return(true);
}
if (baseWeights == null)
{
baseWeights = BoneWeightTableDefault;
}
if (combineWeights == null)
{
combineWeights = BoneWeightTableDefault;
}
switch (faceFlag)
{
case VoxelBase.Face.forward:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
}
break;
case VoxelBase.Face.up:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
}
break;
case VoxelBase.Face.right:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z])
{
return(false);
}
}
break;
case VoxelBase.Face.left:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XYZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z])
{
return(false);
}
}
break;
case VoxelBase.Face.down:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z])
{
return(false);
}
}
break;
case VoxelBase.Face.back:
{
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._XY_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._XYZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex.X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex.X_YZ])
{
return(false);
}
if (baseWeights[(int)VoxelBase.VoxelVertexIndex._X_Y_Z] != combineWeights[(int)VoxelBase.VoxelVertexIndex._X_YZ])
{
return(false);
}
}
break;
}
return(true);
}
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);
}
public bool GetMousePositionVoxelFace(out IntVector3 result, out VoxelBase.Face face)
{
result = IntVector3.zero;
face = 0;
if (objectCore.voxelData == null || objectTarget.voxelData.voxels == null)
{
return(false);
}
if (!CheckMousePositionEditorRects())
{
return(false);
}
Ray localRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
{
Matrix4x4 mat = objectTarget.transform.worldToLocalMatrix;
localRay.direction = mat.MultiplyVector(localRay.direction);
localRay.origin = mat.MultiplyPoint(localRay.origin);
}
{
var boundsBase = objectCore.GetVoxelBounds(IntVector3.zero);
float lengthMin = float.MaxValue;
for (int i = 0; i < objectTarget.voxelData.voxels.Length; i++)
{
if (objectTarget.voxelData.voxels[i].visible == 0)
{
continue;
}
Vector3 position = new Vector3(objectTarget.voxelData.voxels[i].x, objectTarget.voxelData.voxels[i].y, objectTarget.voxelData.voxels[i].z);
Vector3 offset = Vector3.Scale(position, objectTarget.importScale);
var bounds = boundsBase;
bounds.center += offset;
float length;
if (bounds.IntersectRay(localRay, out length))
{
if (length < lengthMin)
{
result = objectTarget.voxelData.voxels[i].position;
lengthMin = length;
#region Face
{
const float Threshold = 0.001f;
var posP = localRay.GetPoint(length);
if (Mathf.Abs(bounds.min.x - posP.x) < Threshold)
{
face = VoxelBase.Face.left;
}
else if (Mathf.Abs(bounds.max.x - posP.x) < Threshold)
{
face = VoxelBase.Face.right;
}
else if (Mathf.Abs(bounds.min.y - posP.y) < Threshold)
{
face = VoxelBase.Face.down;
}
else if (Mathf.Abs(bounds.max.y - posP.y) < Threshold)
{
face = VoxelBase.Face.up;
}
else if (Mathf.Abs(bounds.min.z - posP.z) < Threshold)
{
face = VoxelBase.Face.back;
}
else if (Mathf.Abs(bounds.max.z - posP.z) < Threshold)
{
face = VoxelBase.Face.forward;
}
else
{
Assert.IsTrue(false);
}
}
#endregion
}
}
}
}
return(face != 0);
}
protected override bool CreateMesh()
{
#region ProgressBar
const float MaxProgressCount = 5f;
float ProgressCount = 0;
Action <string> DisplayProgressBar = (info) =>
{
if (!EditorApplication.isPlaying && voxelBase.voxelData.voxels.Length > 10000)
{
EditorUtility.DisplayProgressBar("Create Mesh...", string.Format("{0} / {1}", ProgressCount, MaxProgressCount), (ProgressCount++ / MaxProgressCount));
}
};
#endregion
DisplayProgressBar("");
#region Material
{
if (voxelObject.materialData == null)
{
voxelObject.materialData = new List <MaterialData>();
}
if (voxelObject.materialData.Count == 0)
{
voxelObject.materialData.Add(null);
}
for (int i = 0; i < voxelObject.materialData.Count; i++)
{
if (voxelObject.materialData[i] == null)
{
voxelObject.materialData[i] = new MaterialData();
}
}
if (voxelObject.materials == null)
{
voxelObject.materials = new List <Material>();
}
if (voxelObject.materials.Count < voxelObject.materialData.Count)
{
for (int i = voxelObject.materials.Count; i < voxelObject.materialData.Count; i++)
{
voxelObject.materials.Add(null);
}
}
else if (voxelObject.materials.Count > voxelObject.materialData.Count)
{
voxelObject.materials.RemoveRange(voxelObject.materialData.Count, voxelObject.materials.Count - voxelObject.materialData.Count);
}
#region Erase
for (int i = 0; i < voxelObject.materialData.Count; i++)
{
List <IntVector3> removeList = new List <IntVector3>();
voxelObject.materialData[i].AllAction((pos) =>
{
if (voxelObject.voxelData.VoxelTableContains(pos) < 0)
{
removeList.Add(pos);
}
});
for (int j = 0; j < removeList.Count; j++)
{
voxelObject.materialData[i].RemoveMaterial(removeList[j]);
}
}
#endregion
}
#endregion
CalcDataCreate(voxelBase.voxelData.voxels);
#region RemoveChunk
var chunkObjects = FindChunkComponents();
{
bool chunkObjectsUpdate = false;
bool[] enableTale = new bool[chunkObjects.Length];
if (!removeAllChunk)
{
for (int i = 0; i < chunkDataList.Count; i++)
{
for (int j = 0; j < chunkObjects.Length; j++)
{
if (chunkDataList[i].position == chunkObjects[j].position)
{
enableTale[j] = true;
break;
}
}
}
}
else
{
removeAllChunk = false;
}
for (int i = 0; i < enableTale.Length; i++)
{
if (!enableTale[i])
{
var go = chunkObjects[i].gameObject;
while (go.transform.childCount > 0)
{
Undo.SetTransformParent(go.transform.GetChild(0), voxelObject.transform, "Remove Chunk");
}
Undo.DestroyObjectImmediate(go);
chunkObjectsUpdate = true;
}
}
if (chunkObjectsUpdate)
{
chunkObjects = FindChunkComponents();
}
}
#endregion
#region AddChunk
int chunkCount = 0;
{
bool chunkObjectsUpdate = false;
for (int i = 0; i < chunkDataList.Count; i++)
{
GameObject chunkObject = null;
for (int j = 0; j < chunkObjects.Length; j++)
{
if (chunkDataList[i].position == chunkObjects[j].position)
{
chunkObject = chunkObjects[j].gameObject;
break;
}
}
if (chunkObject == null)
{
chunkObject = new GameObject(chunkDataList[i].name);
Undo.RegisterCreatedObjectUndo(chunkObject, "Create Chunk");
Undo.SetTransformParent(chunkObject.transform, voxelObject.transform, "Create Chunk");
GameObjectUtility.SetStaticEditorFlags(chunkObject, GameObjectUtility.GetStaticEditorFlags(voxelObject.gameObject));
chunkObject.transform.localPosition = Vector3.Scale(voxelObject.localOffset + chunkDataList[i].area.centerf, voxelObject.importScale);
chunkObject.transform.localRotation = Quaternion.identity;
chunkObject.transform.localScale = Vector3.one;
chunkObject.layer = voxelObject.gameObject.layer;
chunkObject.tag = voxelObject.gameObject.tag;
chunkObjectsUpdate = true;
}
VoxelChunksObjectChunk controller = chunkObject.GetComponent <VoxelChunksObjectChunk>();
if (controller == null)
{
controller = Undo.AddComponent <VoxelChunksObjectChunk>(chunkObject);
}
controller.position = chunkDataList[i].position;
controller.chunkName = chunkDataList[i].name;
chunkCount++;
}
if (chunkObjectsUpdate)
{
chunkObjects = FindChunkComponents();
}
}
#endregion
#region SortChunk
{
List <Transform> objList = new List <Transform>();
var childCount = voxelObject.transform.childCount;
for (int i = 0; i < childCount; i++)
{
objList.Add(voxelObject.transform.GetChild(i));
}
objList.Sort((obj1, obj2) => string.Compare(obj1.name, obj2.name));
for (int i = 0; i < objList.Count; i++)
{
objList[i].SetSiblingIndex(childCount - 1);
}
chunkObjects = FindChunkComponents();
}
#endregion
#region UpdateChunk
for (int i = 0; i < chunkObjects.Length; i++)
{
for (int j = 0; j < chunkDataList.Count; j++)
{
if (chunkObjects[i].position == chunkDataList[j].position)
{
chunkDataList[j].chunkObject = chunkObjects[i];
break;
}
}
}
#endregion
#region UpdateVoxelVisibleFlag
{
for (int i = 0; i < voxelBase.voxelData.voxels.Length; i++)
{
int index;
VoxelBase.Face faceFlags = (VoxelBase.Face) 0;
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x, voxelBase.voxelData.voxels[i].y, voxelBase.voxelData.voxels[i].z + 1);
if (index < 0)
{
faceFlags |= VoxelBase.Face.forward;
}
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x, voxelBase.voxelData.voxels[i].y + 1, voxelBase.voxelData.voxels[i].z);
if (index < 0)
{
faceFlags |= VoxelBase.Face.up;
}
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x + 1, voxelBase.voxelData.voxels[i].y, voxelBase.voxelData.voxels[i].z);
if (index < 0)
{
faceFlags |= VoxelBase.Face.right;
}
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x - 1, voxelBase.voxelData.voxels[i].y, voxelBase.voxelData.voxels[i].z);
if (index < 0)
{
faceFlags |= VoxelBase.Face.left;
}
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x, voxelBase.voxelData.voxels[i].y - 1, voxelBase.voxelData.voxels[i].z);
if (index < 0)
{
faceFlags |= VoxelBase.Face.down;
}
index = voxelBase.voxelData.VoxelTableContains(voxelBase.voxelData.voxels[i].x, voxelBase.voxelData.voxels[i].y, voxelBase.voxelData.voxels[i].z - 1);
if (index < 0)
{
faceFlags |= VoxelBase.Face.back;
}
voxelBase.voxelData.voxels[i].visible = faceFlags;
}
}
#endregion
#region CreateFaceAreaTable
{
for (int i = 0; i < chunkDataList.Count; i++)
{
var voxels = new VoxelData.Voxel[chunkDataList[i].voxels.Count];
for (int j = 0; j < chunkDataList[i].voxels.Count; j++)
{
voxels[j] = voxelBase.voxelData.voxels[chunkDataList[i].voxels[j]];
}
chunkDataList[i].faceAreaTable = CreateFaceArea(voxels);
//
if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Individual)
{
var paletteTable = new int[voxelBase.voxelData.palettes.Length];
for (int j = 0; j < voxelBase.voxelData.palettes.Length; j++)
{
int newIndex = -1;
for (int k = 0; k < chunkDataList[i].palettes.Length; k++)
{
if (chunkDataList[i].palettes[k] == voxelBase.voxelData.palettes[j])
{
newIndex = k;
break;
}
}
paletteTable[j] = newIndex;
}
chunkDataList[i].faceAreaTable.ReplacePalette(paletteTable);
}
}
}
#endregion
#region CreateTexture
if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Combine)
{
#region Combine
var tmpFaceAreaTable = new VoxelData.FaceAreaTable();
for (int i = 0; i < chunkDataList.Count; i++)
{
tmpFaceAreaTable.Merge(chunkDataList[i].faceAreaTable);
}
{
var atlasTextureTmp = voxelObject.atlasTexture;
if (!CreateTexture(tmpFaceAreaTable, voxelBase.voxelData.palettes, ref chunkDataList[0].atlasRectTable, ref atlasTextureTmp, ref chunkDataList[0].atlasRects))
{
EditorUtility.ClearProgressBar();
return(false);
}
voxelObject.atlasTexture = atlasTextureTmp;
{
if (voxelObject.materialData == null)
{
voxelObject.materialData = new List <MaterialData>();
}
if (voxelObject.materialData.Count == 0)
{
voxelObject.materialData.Add(null);
}
for (int i = 0; i < voxelObject.materialData.Count; i++)
{
if (voxelObject.materialData[i] == null)
{
voxelObject.materialData[i] = new MaterialData();
}
}
if (voxelObject.materials == null)
{
voxelObject.materials = new List <Material>();
}
if (voxelObject.materials.Count < voxelObject.materialData.Count)
{
for (int i = voxelObject.materials.Count; i < voxelObject.materialData.Count; i++)
{
voxelObject.materials.Add(null);
}
}
else if (voxelObject.materials.Count > voxelObject.materialData.Count)
{
voxelObject.materials.RemoveRange(voxelObject.materialData.Count, voxelObject.materials.Count - voxelObject.materialData.Count);
}
for (int i = 0; i < voxelObject.materials.Count; i++)
{
if (voxelObject.materials[i] == null)
{
voxelObject.materials[i] = new Material(Shader.Find("Standard"));
}
voxelObject.materials[i].mainTexture = voxelObject.atlasTexture;
}
}
for (int i = 0; i < chunkDataList.Count; i++)
{
chunkDataList[i].atlasRects = chunkDataList[0].atlasRects;
chunkDataList[i].atlasRectTable = chunkDataList[0].atlasRectTable;
chunkDataList[i].chunkObject.materials = null;
chunkDataList[i].chunkObject.atlasTexture = null;
}
}
#endregion
}
else if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Individual)
{
#region Individual
if (voxelObject.materialData == null)
{
voxelObject.materialData = new List <MaterialData>();
}
if (voxelObject.materialData.Count == 0)
{
voxelObject.materialData.Add(null);
}
for (int i = 0; i < voxelObject.materialData.Count; i++)
{
if (voxelObject.materialData[i] == null)
{
voxelObject.materialData[i] = new MaterialData();
}
}
voxelObject.materials = null;
voxelObject.atlasTexture = null;
for (int c = 0; c < chunkDataList.Count; c++)
{
var atlasTextureTmp = chunkDataList[c].chunkObject.atlasTexture;
if (!CreateTexture(chunkDataList[c].faceAreaTable, chunkDataList[c].palettes, ref chunkDataList[c].atlasRectTable, ref atlasTextureTmp, ref chunkDataList[c].atlasRects))
{
EditorUtility.ClearProgressBar();
return(false);
}
chunkDataList[c].chunkObject.atlasTexture = atlasTextureTmp;
{
if (chunkDataList[c].chunkObject.materials == null)
{
chunkDataList[c].chunkObject.materials = new List <Material>();
}
if (chunkDataList[c].chunkObject.materials.Count < voxelObject.materialData.Count)
{
for (int i = chunkDataList[c].chunkObject.materials.Count; i < voxelObject.materialData.Count; i++)
{
chunkDataList[c].chunkObject.materials.Add(null);
}
}
else if (chunkDataList[c].chunkObject.materials.Count > voxelObject.materialData.Count)
{
chunkDataList[c].chunkObject.materials.RemoveRange(voxelObject.materialData.Count, chunkDataList[c].chunkObject.materials.Count - voxelObject.materialData.Count);
}
for (int i = 0; i < chunkDataList[c].chunkObject.materials.Count; i++)
{
if (chunkDataList[c].chunkObject.materials[i] == null)
{
chunkDataList[c].chunkObject.materials[i] = new Material(Shader.Find("Standard"));
}
chunkDataList[c].chunkObject.materials[i].mainTexture = chunkDataList[c].chunkObject.atlasTexture;
}
}
}
#endregion
}
else
{
Assert.IsTrue(false);
}
#endregion
#region CreateMesh
DisplayProgressBar("");
{
if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Combine)
{
#region Combine
if (voxelObject.importMode == VoxelBase.ImportMode.LowPoly)
{
int forward = 0;
int up = 0;
int right = 0;
int left = 0;
int down = 0;
int back = 0;
for (int i = 0; i < chunkDataList.Count; i++)
{
AtlasRectTable atlasRectTable = new AtlasRectTable();
{
atlasRectTable.forward = chunkDataList[i].atlasRectTable.forward.GetRange(forward, chunkDataList[i].faceAreaTable.forward.Count);
forward += chunkDataList[i].faceAreaTable.forward.Count;
atlasRectTable.up = chunkDataList[i].atlasRectTable.up.GetRange(up, chunkDataList[i].faceAreaTable.up.Count);
up += chunkDataList[i].faceAreaTable.up.Count;
atlasRectTable.right = chunkDataList[i].atlasRectTable.right.GetRange(right, chunkDataList[i].faceAreaTable.right.Count);
right += chunkDataList[i].faceAreaTable.right.Count;
atlasRectTable.left = chunkDataList[i].atlasRectTable.left.GetRange(left, chunkDataList[i].faceAreaTable.left.Count);
left += chunkDataList[i].faceAreaTable.left.Count;
atlasRectTable.down = chunkDataList[i].atlasRectTable.down.GetRange(down, chunkDataList[i].faceAreaTable.down.Count);
down += chunkDataList[i].faceAreaTable.down.Count;
atlasRectTable.back = chunkDataList[i].atlasRectTable.back.GetRange(back, chunkDataList[i].faceAreaTable.back.Count);
back += chunkDataList[i].faceAreaTable.back.Count;
}
chunkDataList[i].chunkObject.mesh = CreateMeshOnly(chunkDataList[i].chunkObject.mesh, chunkDataList[i].faceAreaTable, voxelObject.atlasTexture, chunkDataList[i].atlasRects, atlasRectTable, -(voxelObject.localOffset + chunkDataList[i].area.centerf), out chunkDataList[i].chunkObject.materialIndexes);
}
}
else
{
for (int i = 0; i < chunkDataList.Count; i++)
{
var srcMesh = (chunkDataList[i].chunkObject.mesh != null && AssetDatabase.Contains(chunkDataList[i].chunkObject.mesh)) ? chunkDataList[i].chunkObject.mesh : null;
chunkDataList[i].chunkObject.mesh = CreateMeshOnly(srcMesh, chunkDataList[i].faceAreaTable, voxelObject.atlasTexture, chunkDataList[i].atlasRects, chunkDataList[i].atlasRectTable, -(voxelObject.localOffset + chunkDataList[i].area.centerf), out chunkDataList[i].chunkObject.materialIndexes);
}
}
#endregion
}
else if (voxelObject.materialMode == VoxelChunksObject.MaterialMode.Individual)
{
#region Individual
for (int i = 0; i < chunkDataList.Count; i++)
{
chunkDataList[i].chunkObject.mesh = CreateMeshOnly(chunkDataList[i].chunkObject.mesh, chunkDataList[i].faceAreaTable, chunkDataList[i].chunkObject.atlasTexture, chunkDataList[i].atlasRects, chunkDataList[i].atlasRectTable, -(voxelObject.localOffset + chunkDataList[i].area.centerf), out chunkDataList[i].chunkObject.materialIndexes);
}
#endregion
}
else
{
Assert.IsTrue(false);
}
}
#endregion
DisplayProgressBar("");
if (voxelBase.generateLightmapUVs)
{
for (int i = 0; i < chunkDataList.Count; i++)
{
if (chunkDataList[i].chunkObject.mesh.uv.Length > 0)
{
Unwrapping.GenerateSecondaryUVSet(chunkDataList[i].chunkObject.mesh);
}
}
}
DisplayProgressBar("");
SetRendererCompornent();
CreateMeshAfterFree();
RefreshCheckerSave();
EditorUtility.ClearProgressBar();
return(true);
}
protected override bool IsCombineVoxelFace(IntVector3 basePos, IntVector3 combinePos, VoxelBase.Face face)
{
if (voxelChunkPositionTable == null)
{
CreateVoxelChunkPositionTable();
}
return(voxelChunkPositionTable[basePos.x, basePos.y, basePos.z] == voxelChunkPositionTable[combinePos.x, combinePos.y, combinePos.z]);
}
