public static void ISOCut(VCIsoData iso, VCEAction action)
{
List <VCEAlterVoxel> tmpModifies = new List <VCEAlterVoxel> ();
foreach (KeyValuePair <int, VCVoxel> kvp in iso.m_Voxels)
{
int pos0 = kvp.Key + 1;
int pos1 = kvp.Key - 1;
int pos2 = kvp.Key + (1 << 10);
int pos3 = kvp.Key - (1 << 10);
int pos4 = kvp.Key + (1 << 20);
int pos5 = kvp.Key - (1 << 20);
if (kvp.Value.Volume < VCEMath.MC_ISO_VALUE)
{
if (iso.GetVoxel(pos0).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos1).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos2).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos3).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos4).Volume < VCEMath.MC_ISO_VALUE &&
iso.GetVoxel(pos5).Volume < VCEMath.MC_ISO_VALUE)
{
VCEAlterVoxel modify = new VCEAlterVoxel(kvp.Key, kvp.Value, new VCVoxel(0, 0));
tmpModifies.Add(modify);
action.Modifies.Add(modify);
}
}
}
foreach (VCEAlterVoxel t in tmpModifies)
{
t.Redo();
}
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
IntVector3 draw = m_Target.cursor + m_Offset;
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
VCEditor.s_Mirror.MirrorVoxel(draw);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
int voxel_pos = VCIsoData.IPosToKey(draw);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
VCEditor.Instance.m_MainCamera.GetComponent <VCECamera>().SetTarget(
(draw.ToVector3() + Vector3.one * 0.5f) * VCEditor.s_Scene.m_Setting.m_VoxelSize);
}
// Gizmo Functions
// All Gizmo Begin
void OnGizmoBegin()
{
m_GizmoAction = new VCEAction();
foreach (SelectInfo si in m_Selection)
{
si.m_OldPosition = si.m_DragPosition = si.m_NewPosition = si.m_Component.m_Data.m_Position;
si.m_OldRotation = si.m_DragRotation = si.m_NewRotation = si.m_Component.m_Data.m_Rotation;
si.m_OldScale = si.m_DragScale = si.m_NewScale = si.m_Component.m_Data.m_Scale;
}
}
public void DeleteSelection()
{
m_Action = new VCEAction();
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (KeyValuePair <int, byte> kvp in m_SelectionMgr.m_Selection)
{
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 pos = VCIsoData.KeyToIPos(kvp.Key);
VCEditor.s_Mirror.MirrorVoxel(pos);
float strength = (float)(kvp.Value) / 255.0f;
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = old_voxel;
new_voxel.VolumeF = new_voxel.VolumeF * (1 - strength);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
float strength = (float)(kvp.Value) / 255.0f;
int voxel_pos = kvp.Key;
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = old_voxel;
new_voxel.VolumeF = new_voxel.VolumeF * (1 - strength);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
ColorSelection(VCIsoData.BLANK_COLOR, false, true);
if (m_Action.Modifies.Count > 0)
{
m_Action.DoButNotRegister();
VCUtils.ISOCut(VCEditor.s_Scene.m_IsoData, m_Action);
m_Action.Register();
VCEStatusBar.ShowText("Selected voxels have been removed".ToLocalizationString(), 2);
}
ClearSelection();
}
// Undo
public static bool Undo()
{
if (m_Undos.Count > 0)
{
VCEAction action = m_Undos[0];
action.Undo();
m_Redos.Insert(0, action);
m_Undos.RemoveAt(0);
GC.Collect();
return(true);
}
return(false);
}
// Do an action
public static void AddAction(VCEAction action)
{
if (action.Modifies.Count == 0)
{
return;
}
ClearRedos();
m_Undos.Insert(0, action);
if (m_Undos.Count > MAX_ACTION_CNT)
{
m_Undos[MAX_ACTION_CNT].Destroy();
m_Undos.RemoveAt(MAX_ACTION_CNT);
}
}
// Delete Selected Components
public void DeleteSelection()
{
if (UsingGizmo)
{
return;
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
m_Action = new VCEAction();
int del_cnt = 0;
foreach (SelectInfo si in m_Selection)
{
VCEComponentTool ct = si.m_Component;
List <VCEComponentTool> images = MirrorImage(ct);
images.Add(ct);
foreach (VCEComponentTool image in images)
{
int index = VCEditor.s_Scene.m_IsoData.GetComponentIndex(image.m_Data);
if (index < 0)
{
continue;
}
VCEDelComponent modify = new VCEDelComponent(index, image.m_Data);
modify.Redo();
m_Action.Modifies.Add(modify);
del_cnt++;
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Register();
ClearSelection();
}
if (del_cnt > 0)
{
VCEStatusBar.ShowText(del_cnt.ToString() + " " + "component(s) have been removed".ToLocalizationString(), 4);
}
m_MouseOnGizmo = false;
}
//
// Functions
//
public void ExtrudeSelection(int x, int y, int z)
{
if (x == 0 && y == 0 && z == 0)
{
return;
}
m_Action = new VCEAction();
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
List <int> new_select_keys = new List <int> ();
List <int> new_select_values = new List <int> ();
foreach (KeyValuePair <int, byte> kvp in m_SelectionMgr.m_Selection)
{
float strength = (float)(kvp.Value) / 255.0f;
IntVector3 ipos = VCIsoData.KeyToIPos(kvp.Key);
ipos.x += x;
ipos.y += y;
ipos.z += z;
if (VCEditor.s_Scene.m_IsoData.IsPointIn(ipos))
{
int voxel_pos = VCIsoData.IPosToKey(ipos);
new_select_keys.Add(voxel_pos);
new_select_values.Add((int)kvp.Value);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
//IntVector3 real = ipos;
VCEditor.s_Mirror.MirrorVoxel(ipos);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
IntVector3 image = VCEditor.s_Mirror.Output[i];
if (VCEditor.s_Scene.m_IsoData.IsPointIn(image))
{
voxel_pos = VCIsoData.IPosToKey(image);
VCVoxel src_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(kvp.Key);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = src_voxel;
if (strength == 1)
{
new_voxel.VolumeF = old_voxel.VolumeF + src_voxel.VolumeF;
}
else
{
new_voxel.VolumeF = old_voxel.VolumeF + src_voxel.VolumeF * Mathf.Lerp(Mathf.Pow(strength, 0.3f), 1, 0.3f);
}
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
VCVoxel src_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(kvp.Key);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = src_voxel;
if (strength == 1)
{
new_voxel.VolumeF = old_voxel.VolumeF + src_voxel.VolumeF;
}
else
{
new_voxel.VolumeF = old_voxel.VolumeF + src_voxel.VolumeF * Mathf.Lerp(Mathf.Pow(strength, 0.3f), 1, 0.3f);
}
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// Clear new area's color
ColorSelection(VCIsoData.BLANK_COLOR, false, true);
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
// Select new extruded area
m_SelectionMgr.m_Selection.Clear();
for (int i = 0; i < new_select_keys.Count; ++i)
{
if (!VCEditor.s_Scene.m_IsoData.IsGarbageVoxel(new_select_keys[i]))
{
m_SelectionMgr.m_Selection.Add(new_select_keys[i], (byte)(new_select_values[i]));
}
}
m_SelectionMgr.RebuildSelectionBoxes();
}
protected override void Do()
{
m_Action = new VCEAction();
VCComponentData data = VCComponentData.Create(VCEditor.SelectedPart);
if (data != null)
{
data.m_ComponentId = VCEditor.SelectedPart.m_ID;
data.m_Type = VCEditor.SelectedPart.m_Type;
data.m_Position = m_PartInst.transform.localPosition;
data.m_Rotation = Vector3.zero;
data.m_Scale = Vector3.one;
data.m_Visible = true;
data.m_CurrIso = VCEditor.s_Scene.m_IsoData;
data.Validate();
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.MirrorComponent(data);
for (int i = VCEditor.s_Mirror.OutputCnt - 1; i >= 0; --i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
if (VCEditor.s_Scene.m_IsoData.IsComponentIn(image.m_Position))
{
List <VCComponentData> conflicts = VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(image.m_Position, image.m_ComponentId);
foreach (VCComponentData conflict in conflicts)
{
if (conflict.m_Scale != image.m_Scale)
{
continue;
}
if (conflict.m_Visible != image.m_Visible)
{
continue;
}
if (image is IVCMultiphaseComponentData && conflict is IVCMultiphaseComponentData)
{
if ((image as IVCMultiphaseComponentData).Phase != (conflict as IVCMultiphaseComponentData).Phase)
{
continue;
}
}
// Delete conflict
int index = VCEditor.s_Scene.m_IsoData.GetComponentIndex(conflict);
if (index < 0)
{
continue;
}
VCEDelComponent del = new VCEDelComponent(index, conflict);
del.Redo();
m_Action.Modifies.Add(del);
}
VCEAddComponent modify = new VCEAddComponent(VCEditor.s_Scene.m_IsoData.m_Components.Count, image);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
m_Action.Register();
}
// No mirror
else
{
VCFixedHandPartData fixdata = data as VCFixedHandPartData;
if (fixdata != null)
{
fixdata.m_LeftHand = data.m_Position.x < VCEditor.s_Scene.m_IsoData.m_HeadInfo.xSize * VCEditor.s_Scene.m_Setting.m_VoxelSize * 0.5f;
}
VCEAddComponent modify = new VCEAddComponent(VCEditor.s_Scene.m_IsoData.m_Components.Count, data);
m_Action.Modifies.Add(modify);
m_Action.Do();
}
}
else
{
Debug.LogWarning("Forget to add this part's implementation ?");
}
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
float maskx = (m_Direction == ECoordAxis.X) ? 0.0f : 1.0f;
float masky = (m_Direction == ECoordAxis.Y) ? 0.0f : 1.0f;
float maskz = (m_Direction == ECoordAxis.Z) ? 0.0f : 1.0f;
int imaskx = (m_Direction == ECoordAxis.X) ? 0 : 1;
int imasky = (m_Direction == ECoordAxis.Y) ? 0 : 1;
int imaskz = (m_Direction == ECoordAxis.Z) ? 0 : 1;
float invmaskx = (m_Direction == ECoordAxis.X) ? 1000000.0f : 1.0f;
float invmasky = (m_Direction == ECoordAxis.Y) ? 1000000.0f : 1.0f;
float invmaskz = (m_Direction == ECoordAxis.Z) ? 1000000.0f : 1.0f;
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
IntVector3 min = Min;
IntVector3 max = Max;
Vector3 extend = Size.ToVector3() * 0.5f;
Vector3 center = min.ToVector3() + extend;
Vector3 inv_scale = Vector3.one;
float radius = Mathf.Max(extend.x * maskx, extend.y * masky, extend.z * maskz);
float min_dimension = Mathf.Max(Mathf.Min(extend.x * invmaskx, extend.y * invmasky, extend.z * invmaskz) - 0.5f, 1);
if (extend.x * maskx >= extend.y * masky && extend.x * maskx >= extend.z * maskz)
{
inv_scale = new Vector3(1, extend.x / extend.y, extend.x / extend.z);
}
else if (extend.y * masky >= extend.x * maskx && extend.y * masky >= extend.z * maskz)
{
inv_scale = new Vector3(extend.y / extend.x, 1, extend.y / extend.z);
}
else
{
inv_scale = new Vector3(extend.z / extend.x, extend.z / extend.y, 1);
}
float sizex = max.x - min.x + 0.5f;
float sizey = max.y - min.y + 0.5f;
float sizez = max.z - min.z + 0.5f;
for (int x = min.x - 2 * imaskx; x <= max.x + 2 * imaskx; ++x)
{
for (int y = min.y - 2 * imasky; y <= max.y + 2 * imasky; ++y)
{
for (int z = min.z - 2 * imaskz; z <= max.z + 2 * imaskz; ++z)
{
float lerpt = 1;
if (m_Direction == ECoordAxis.X)
{
lerpt = (float)(x - min.x) / sizex;
}
else if (m_Direction == ECoordAxis.Y)
{
lerpt = (float)(y - min.y) / sizey;
}
else if (m_Direction == ECoordAxis.Z)
{
lerpt = (float)(z - min.z) / sizez;
}
float scl = Mathf.Lerp(m_NegativeScale, m_PositiveScale, lerpt);
if (scl * radius < 0.01f)
{
scl = 0.01f / radius;
}
IntVector3 pos = new IntVector3(x, y, z);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
Vector3 sphere_coord = (pos.ToVector3() + Vector3.one * 0.5f) - center;
sphere_coord.x *= inv_scale.x;
sphere_coord.y *= inv_scale.y;
sphere_coord.z *= inv_scale.z;
sphere_coord.x *= maskx;
sphere_coord.y *= masky;
sphere_coord.z *= maskz;
float _radius = scl * radius;
float delta = (_radius - sphere_coord.magnitude) / _radius;
float volume = Mathf.Clamp(delta * min_dimension * scl * VCEMath.MC_ISO_VALUEF + VCEMath.MC_ISO_VALUEF, 0, 255.49f);
VCEditor.s_Mirror.MirrorVoxel(pos);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
pos = VCEditor.s_Mirror.Output[i];
if (VCEditor.s_Scene.m_IsoData.IsPointIn(pos))
{
int voxel_pos = VCIsoData.IPosToKey(pos);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = 0;
if (old_voxel.Volume == 0)
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
else if (old_voxel.Volume < VCEMath.MC_ISO_VALUE)
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
else
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
VCVoxel old_st_voxel = VCEditor.s_Scene.m_Stencil.GetVoxel(voxel_pos);
new_voxel.Volume = (new_voxel.Volume > old_st_voxel.Volume) ? (new_voxel.Volume) : (old_st_voxel.Volume);
VCEditor.s_Scene.m_Stencil.SetVoxel(voxel_pos, new_voxel);
}
}
}
// No mirror
else
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(pos))
{
Vector3 sphere_coord = (pos.ToVector3() + Vector3.one * 0.5f) - center;
sphere_coord.x *= inv_scale.x;
sphere_coord.y *= inv_scale.y;
sphere_coord.z *= inv_scale.z;
sphere_coord.x *= maskx;
sphere_coord.y *= masky;
sphere_coord.z *= maskz;
float _radius = scl * radius;
float delta = (_radius - sphere_coord.magnitude) / _radius;
float volume = Mathf.Clamp(delta * min_dimension * scl * VCEMath.MC_ISO_VALUEF + VCEMath.MC_ISO_VALUEF, 0, 255.49f);
int voxel_pos = VCIsoData.IPosToKey(pos);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = 0;
if (old_voxel.Volume == 0)
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
else if (old_voxel.Volume < VCEMath.MC_ISO_VALUE)
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
else
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
VCEditor.s_Scene.m_Stencil.SetVoxel(voxel_pos, new_voxel);
}
}
}
}
}
VCEditor.s_Scene.m_Stencil.NormalizeAllVoxels();
foreach (KeyValuePair <int, VCVoxel> kvp in VCEditor.s_Scene.m_Stencil.m_Voxels)
{
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(kvp.Key);
VCVoxel new_voxel = VCEditor.s_Scene.m_Stencil.GetVoxel(kvp.Key);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(kvp.Key, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
VCEditor.s_Scene.m_Stencil.Clear();
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
ResetDrawing();
}
protected override void Do()
{
if (VCEditor.SelectedDecalGUID == 0)
{
return;
}
if (VCEditor.SelectedDecalIndex < 0)
{
return;
}
if (VCEditor.SelectedDecal == null)
{
return;
}
m_Action = new VCEAction();
VCDecalData dcldata = VCComponentData.CreateDecal() as VCDecalData;
if (dcldata != null)
{
dcldata.m_ComponentId = VCDecalData.s_ComponentId;
dcldata.m_Type = EVCComponent.cpDecal;
dcldata.m_Position = m_DecalInst.transform.localPosition;
dcldata.m_Rotation = VCEMath.NormalizeEulerAngle(m_DecalInst.transform.localEulerAngles);
dcldata.m_Scale = Vector3.one;
dcldata.m_Visible = true;
dcldata.m_CurrIso = VCEditor.s_Scene.m_IsoData;
dcldata.m_Guid = VCEditor.SelectedDecalGUID;
dcldata.m_AssetIndex = VCEditor.SelectedDecalIndex;
dcldata.m_Size = m_DecalInst.m_Size;
dcldata.m_Depth = m_DecalInst.m_Depth;
dcldata.m_Mirrored = m_DecalInst.m_Mirrored;
dcldata.m_ShaderIndex = m_DecalInst.m_ShaderIndex;
dcldata.m_Color = m_DecalInst.m_Color;
dcldata.Validate();
ulong olddcl_guid = VCEditor.s_Scene.m_IsoData.DecalGUID(VCEditor.SelectedDecalIndex);
ulong newdcl_guid = VCEditor.SelectedDecalGUID;
if (olddcl_guid != newdcl_guid)
{
VCEAlterDecalMap modify = new VCEAlterDecalMap(VCEditor.SelectedDecalIndex, olddcl_guid, newdcl_guid);
modify.Redo();
m_Action.Modifies.Add(modify);
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.MirrorComponent(dcldata);
for (int i = VCEditor.s_Mirror.OutputCnt - 1; i >= 0; --i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
if (VCEditor.s_Scene.m_IsoData.IsComponentIn(image.m_Position))
{
VCEAddComponent modify = new VCEAddComponent(VCEditor.s_Scene.m_IsoData.m_Components.Count, image);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
}
// No mirror
else
{
VCEAddComponent modify = new VCEAddComponent(VCEditor.s_Scene.m_IsoData.m_Components.Count, dcldata);
modify.Redo();
m_Action.Modifies.Add(modify);
}
m_Action.Register();
}
else
{
Debug.LogWarning("Decal data create failed");
}
}
public void ApplyInspectorChange()
{
if (m_Selection.Count != 1)
{
return;
}
if (m_DataInspector == null)
{
return;
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
m_Action = new VCEAction();
VCComponentData old_data = m_Selection[0].m_Component.m_Data;
VCComponentData new_data = m_DataInspector.GetComponent <VCEUIComponentInspector>().Get();
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCComponentData[] old_img_data = new VCComponentData [8];
VCEditor.s_Mirror.MirrorComponent(old_data);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
old_img_data[i] = VCEditor.s_Mirror.ComponentOutput[i].Copy();
}
VCEditor.s_Mirror.MirrorComponent(new_data);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
List <VCComponentData> edits = VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(old_img_data[i].m_Position, image.m_ComponentId);
foreach (VCComponentData iter in edits)
{
if (i > 0 && m_Selection.Find(it => it.m_Component.m_Data == iter) != null)
{
continue;
}
if (!VCEMath.IsEqualRotation(iter.m_Rotation, old_img_data[i].m_Rotation))
{
continue;
}
if (!VCEMath.IsEqualVector(iter.m_Scale, old_img_data[i].m_Scale))
{
continue;
}
if (iter.m_Visible != old_img_data[i].m_Visible)
{
continue;
}
if (old_img_data[i] is IVCMultiphaseComponentData && iter is IVCMultiphaseComponentData)
{
if ((old_img_data[i] as IVCMultiphaseComponentData).Phase != (iter as IVCMultiphaseComponentData).Phase)
{
continue;
}
}
int index = VCEditor.s_Scene.m_IsoData.GetComponentIndex(iter);
if (index < 0)
{
continue;
}
// Special process for wheels
if (i != 0 && image is VCQuadphaseFixedPartData)
{
(image as VCQuadphaseFixedPartData).m_Phase =
((image as VCQuadphaseFixedPartData).m_Phase & 1) | ((iter as VCQuadphaseFixedPartData).m_Phase & 2);
}
VCEAlterComponent modify = new VCEAlterComponent(index, iter, image);
m_Action.Modifies.Add(modify);
}
}
}
// No mirror
else
{
int index = VCEditor.s_Scene.m_IsoData.GetComponentIndex(old_data);
if (index < 0)
{
return;
}
VCEAlterComponent modify = new VCEAlterComponent(index, old_data, new_data);
m_Action.Modifies.Add(modify);
}
VCEStatusBar.ShowText("Changes applied".ToLocalizationString(), 2);
m_Action.Do();
}
// All Gizmo End
void OnGizmoEnd()
{
if (m_GizmoAction != null)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (SelectInfo si in m_Selection)
{
bool modified = false;
if (!VCEMath.IsEqualVector(si.m_NewPosition, si.m_OldPosition))
{
modified = true;
}
if (!VCEMath.IsEqualRotation(si.m_NewRotation, si.m_OldRotation))
{
modified = true;
}
if (!VCEMath.IsEqualVector(si.m_NewScale, si.m_OldScale))
{
modified = true;
}
if (modified)
{
VCEAlterComponentTransform modify = new VCEAlterComponentTransform(
VCEditor.s_Scene.m_IsoData.GetComponentIndex(si.m_Component.m_Data),
si.m_OldPosition, si.m_OldRotation, si.m_OldScale,
si.m_NewPosition, si.m_NewRotation, si.m_NewScale);
m_GizmoAction.Modifies.Add(modify);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
Vector3[] old_poses = new Vector3[8];
Vector3[] old_rots = new Vector3[8];
Vector3[] old_scales = new Vector3[8];
VCEditor.s_Mirror.MirrorComponent(si.m_Component.m_Data);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
old_poses[i] = VCEditor.s_Mirror.ComponentOutput[i].m_Position;
old_rots[i] = VCEditor.s_Mirror.ComponentOutput[i].m_Rotation;
old_scales[i] = VCEditor.s_Mirror.ComponentOutput[i].m_Scale;
}
VCComponentData tmpdata = si.m_Component.m_Data.Copy();
tmpdata.m_Position = si.m_NewPosition;
tmpdata.m_Rotation = si.m_NewRotation;
tmpdata.m_Scale = si.m_NewScale;
VCEditor.s_Mirror.MirrorComponent(tmpdata);
for (int i = 1; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
image.Validate();
List <VCComponentData> edits = VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(old_poses[i], image.m_ComponentId);
foreach (VCComponentData iter in edits)
{
if (!VCEMath.IsEqualRotation(iter.m_Rotation, old_rots[i]))
{
continue;
}
if (iter.m_Scale != old_scales[i])
{
continue;
}
if (iter.m_Visible != image.m_Visible)
{
continue;
}
if (image is IVCMultiphaseComponentData && iter is IVCMultiphaseComponentData)
{
if ((image as IVCMultiphaseComponentData).Phase != (iter as IVCMultiphaseComponentData).Phase)
{
continue;
}
}
if (m_Selection.Find(it => it.m_Component.m_Data == iter) == null)
{
VCEAlterComponentTransform modify_mirror = new VCEAlterComponentTransform(
VCEditor.s_Scene.m_IsoData.GetComponentIndex(iter),
iter.m_Position, iter.m_Rotation, iter.m_Scale,
image.m_Position, image.m_Rotation, image.m_Scale);
m_GizmoAction.Modifies.Add(modify_mirror);
}
}
}
}
// End 'mirror'
}
}
if (m_GizmoAction.Modifies.Count > 0)
{
m_GizmoAction.Do();
m_GizmoAction = null;
}
}
else
{
Debug.LogWarning("Must be some problem here!");
}
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
Vector3 pa = Vector3.zero;
Vector3 pb = Vector3.zero;
Vector3 pc = Vector3.zero;
switch (m_Direction)
{
default:
case 0: pa = new Vector3(Min.x, Min.y, Min.z - 0.5f); pb = new Vector3(Max.x + 1, Max.y + 1.5f, Max.z + 1); pc = new Vector3(Max.x + 1, Min.y, Min.z - 0.5f); break;
case 1: pa = new Vector3(Max.x + 1, Max.y + 1, Max.z + 1.5f); pb = new Vector3(Min.x, Min.y - 0.5f, Min.z); pc = new Vector3(Max.x + 1, Min.y - 0.5f, Min.z); break;
case 2: pa = new Vector3(Min.x, Max.y + 1.5f, Min.z); pb = new Vector3(Max.x + 1, Min.y, Max.z + 1.5f); pc = new Vector3(Max.x + 1, Max.y + 1.5f, Min.z); break;
case 3: pa = new Vector3(Max.x + 1, Min.y - 0.5f, Max.z + 1); pb = new Vector3(Min.x, Max.y + 1, Min.z - 0.5f); pc = new Vector3(Max.x + 1, Max.y + 1, Min.z - 0.5f); break;
case 4: pa = new Vector3(Min.x - 0.5f, Min.y, Min.z); pb = new Vector3(Max.x + 1, Max.y + 1, Max.z + 1.5f); pc = new Vector3(Min.x - 0.5f, Max.y + 1, Min.z); break;
case 5: pa = new Vector3(Max.x + 1.5f, Max.y + 1, Max.z + 1); pb = new Vector3(Min.x, Min.y, Min.z - 0.5f); pc = new Vector3(Min.x, Max.y + 1, Min.z - 0.5f); break;
case 6: pa = new Vector3(Max.x + 1, Min.y, Min.z - 0.5f); pb = new Vector3(Min.x - 0.5f, Max.y + 1, Max.z + 1); pc = new Vector3(Max.x + 1, Max.y + 1, Min.z - 0.5f); break;
case 7: pa = new Vector3(Min.x, Max.y + 1, Max.z + 1.5f); pb = new Vector3(Max.x + 1.5f, Min.y, Min.z); pc = new Vector3(Max.x + 1.5f, Max.y + 1, Min.z); break;
case 8: pa = new Vector3(Min.x, Min.y - 0.5f, Min.z); pb = new Vector3(Max.x + 1.5f, Max.y + 1, Max.z + 1); pc = new Vector3(Min.x, Min.y - 0.5f, Max.z + 1); break;
case 9: pa = new Vector3(Max.x + 1, Max.y + 1.5f, Max.z + 1); pb = new Vector3(Min.x - 0.5f, Min.y, Min.z); pc = new Vector3(Min.x - 0.5f, Min.y, Max.z + 1); break;
case 10: pa = new Vector3(Max.x + 1.5f, Min.y, Min.z); pb = new Vector3(Min.x, Max.y + 1.5f, Max.z + 1); pc = new Vector3(Max.x + 1.5f, Min.y, Max.z + 1); break;
case 11: pa = new Vector3(Min.x - 0.5f, Max.y + 1, Max.z + 1); pb = new Vector3(Max.x + 1, Min.y - 0.5f, Min.z); pc = new Vector3(Max.x + 1, Min.y - 0.5f, Max.z + 1); break;
}
//Vector3 offset = m_Offset * Vector3.up;
//Vector3 offset2 = (m_Offset-m_Thickness) * Vector3.up;
Plane pl = new Plane(pa, pb, pc);
//Plane pl2 = new Plane (pa+offset2, pc+offset2, pb+offset2);
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
IntVector3 min = Min;
IntVector3 max = Max;
for (int x = min.x; x <= max.x; ++x)
{
for (int y = min.y; y <= max.y; ++y)
{
for (int z = min.z; z <= max.z; ++z)
{
float volume = VCEMath.DetermineVolume(x, y, z, pl);
//float volume2 = VCEMath.DetermineVolume(x,y,z,pl2);
int vol = Mathf.RoundToInt(volume);
if (vol == 0)
{
continue;
}
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.MirrorVoxel(new IntVector3(x, y, z));
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel((byte)vol, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
int voxel_pos = VCIsoData.IPosToKey(new IntVector3(x, y, z));
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel((byte)vol, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
ResetDrawing();
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
IntVector3 min = Min;
IntVector3 max = Max;
Vector3 extend = Size.ToVector3() * 0.5f;
Vector3 center = min.ToVector3() + extend;
Vector3 inv_scale = Vector3.one;
float radius = Mathf.Max(extend.x, extend.y, extend.z);
float min_dimension = Mathf.Max(Mathf.Min(extend.x, extend.y, extend.z) - 0.5f, 1);
if (extend.x >= extend.y && extend.x >= extend.z)
{
inv_scale = new Vector3(1, extend.x / extend.y, extend.x / extend.z);
}
else if (extend.y >= extend.x && extend.y >= extend.z)
{
inv_scale = new Vector3(extend.y / extend.x, 1, extend.y / extend.z);
}
else
{
inv_scale = new Vector3(extend.z / extend.x, extend.z / extend.y, 1);
}
for (int x = min.x - 2; x <= max.x + 2; ++x)
{
for (int y = min.y - 2; y <= max.y + 2; ++y)
{
for (int z = min.z - 2; z <= max.z + 2; ++z)
{
IntVector3 pos = new IntVector3(x, y, z);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
Vector3 sphere_coord = (pos.ToVector3() + Vector3.one * 0.5f) - center;
sphere_coord.x *= inv_scale.x;
sphere_coord.y *= inv_scale.y;
sphere_coord.z *= inv_scale.z;
float delta = (radius - sphere_coord.magnitude) / radius;
float volume = Mathf.Clamp(delta * min_dimension * VCEMath.MC_ISO_VALUEF + VCEMath.MC_ISO_VALUEF, 0, 255.49f);
VCEditor.s_Mirror.MirrorVoxel(pos);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
pos = VCEditor.s_Mirror.Output[i];
if (VCEditor.s_Scene.m_IsoData.IsPointIn(pos))
{
int voxel_pos = VCIsoData.IPosToKey(pos);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = 0;
if (old_voxel.Volume == 0)
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
else if (old_voxel.Volume < VCEMath.MC_ISO_VALUE)
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
else
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
VCVoxel old_st_voxel = VCEditor.s_Scene.m_Stencil.GetVoxel(voxel_pos);
new_voxel.Volume = (new_voxel.Volume > old_st_voxel.Volume) ? (new_voxel.Volume) : (old_st_voxel.Volume);
VCEditor.s_Scene.m_Stencil.SetVoxel(voxel_pos, new_voxel);
}
}
}
// No mirror
else
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(pos))
{
Vector3 sphere_coord = (pos.ToVector3() + Vector3.one * 0.5f) - center;
sphere_coord.x *= inv_scale.x;
sphere_coord.y *= inv_scale.y;
sphere_coord.z *= inv_scale.z;
float delta = (radius - sphere_coord.magnitude) / radius;
float volume = Mathf.Clamp(delta * min_dimension * VCEMath.MC_ISO_VALUEF + VCEMath.MC_ISO_VALUEF, 0, 255.49f);
int voxel_pos = VCIsoData.IPosToKey(pos);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = 0;
if (old_voxel.Volume == 0)
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
else if (old_voxel.Volume < VCEMath.MC_ISO_VALUE)
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
else
{
if (volume < VCEMath.MC_ISO_VALUE)
{
new_voxel = old_voxel;
}
else
{
new_voxel = new VCVoxel((byte)(volume), (byte)VCEditor.SelectedVoxelType);
}
}
VCEditor.s_Scene.m_Stencil.SetVoxel(voxel_pos, new_voxel);
}
}
}
}
}
VCEditor.s_Scene.m_Stencil.NormalizeAllVoxels();
foreach (KeyValuePair <int, VCVoxel> kvp in VCEditor.s_Scene.m_Stencil.m_Voxels)
{
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(kvp.Key);
VCVoxel new_voxel = VCEditor.s_Scene.m_Stencil.GetVoxel(kvp.Key);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(kvp.Key, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
VCEditor.s_Scene.m_Stencil.Clear();
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
ResetDrawing();
}
public void TextureSelection()
{
if (!VCEditor.Instance.m_UI.m_MaterialTab.isChecked)
{
return;
}
if (VCEditor.SelectedVoxelType < 0)
{
return;
}
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (KeyValuePair <int, byte> kvp in m_SelectionMgr.m_Selection)
{
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 pos = VCIsoData.KeyToIPos(kvp.Key);
VCEditor.s_Mirror.MirrorVoxel(pos);
float strength = (float)(kvp.Value) / 255.0f;
if (strength < 0.5f)
{
continue;
}
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(old_voxel.Volume, (byte)(VCEditor.SelectedVoxelType));
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
modify.Redo();
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
float strength = (float)(kvp.Value) / 255.0f;
if (strength < 0.5f)
{
continue;
}
int voxel_pos = kvp.Key;
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(old_voxel.Volume, (byte)(VCEditor.SelectedVoxelType));
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
VCEStatusBar.ShowText("Selected voxels have been textured".ToLocalizationString(), 2);
}
}
public void ColorSelection(Color32 color, bool consider_strength = true, bool action_segment = false)
{
if (!VCEditor.Instance.m_UI.m_PaintTab.isChecked)
{
return;
}
if (!action_segment)
{
m_Action = new VCEAction();
}
bool modified = false;
VCEUpdateColorSign sign_b = new VCEUpdateColorSign(false, true);
m_Action.Modifies.Add(sign_b);
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (SelBox sb in m_SelectionMgr.m_GL.m_Boxes)
{
float t = (float)(sb.m_Val) / 255.0f;
byte code; // This is a filter code, when color key was not on edge or vertex, their is no point to color this key.
float x, y, z;
for (x = sb.m_Box.xMin, code = 0; x <= sb.m_Box.xMax + 1.01f; x += 0.5f, code ^= 1)
{
for (y = sb.m_Box.yMin, code &= 1; y <= sb.m_Box.yMax + 1.01f; y += 0.5f, code ^= 2)
{
if (code == 0 || code == 4)
{
continue; // code 0, 4, no point to color
}
for (z = sb.m_Box.zMin, code &= 3; z <= sb.m_Box.zMax + 1.01f; z += 0.5f, code ^= 4)
{
if (code == 1 || code == 2)
{
continue; // code 1, 2, no point to color
}
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
IntVector3 color_pos = VCIsoData.IPosToColorPos(new Vector3(x, y, z));
VCEditor.s_Mirror.MirrorColor(color_pos);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsColorPosIn(VCEditor.s_Mirror.Output[i]))
{
int key = VCIsoData.ColorPosToColorKey(VCEditor.s_Mirror.Output[i]);
Color32 old_color = VCEditor.s_Scene.m_IsoData.GetColor(key);
Color32 new_color = consider_strength ? Color32.Lerp(old_color, color, t) : color;
if (old_color.r == new_color.r && old_color.g == new_color.g &&
old_color.b == new_color.b && old_color.a == new_color.a)
{
continue;
}
VCEAlterColor modify = new VCEAlterColor(key, old_color, new_color);
modify.Redo();
m_Action.Modifies.Add(modify);
modified = true;
}
}
}
// No mirror
else
{
int key = VCIsoData.IPosToColorKey(new Vector3(x, y, z));
Color32 old_color = VCEditor.s_Scene.m_IsoData.GetColor(key);
Color32 new_color = consider_strength ? Color32.Lerp(old_color, color, t) : color;
if (old_color.r == new_color.r && old_color.g == new_color.g &&
old_color.b == new_color.b && old_color.a == new_color.a)
{
continue;
}
VCEAlterColor modify = new VCEAlterColor(key, old_color, new_color);
m_Action.Modifies.Add(modify);
modified = true;
}
}
}
}
}
VCEUpdateColorSign sign_f = new VCEUpdateColorSign(true, false);
m_Action.Modifies.Add(sign_f);
if (action_segment && !modified)
{
m_Action.Modifies.RemoveRange(m_Action.Modifies.Count - 2, 2);
}
if (!action_segment && m_Action.Modifies.Count > 2)
{
m_Action.Do();
if (color.r == VCIsoData.BLANK_COLOR.r &&
color.g == VCIsoData.BLANK_COLOR.g &&
color.b == VCIsoData.BLANK_COLOR.b &&
color.a == VCIsoData.BLANK_COLOR.a)
{
VCEStatusBar.ShowText("Selection color have been erased".ToLocalizationString(), 2);
}
else
{
VCEStatusBar.ShowText("Selected voxels have been painted".ToLocalizationString(), 2);
}
}
}
protected override void Do()
{
m_Action = new VCEAction();
ulong oldmat_guid = VCEditor.s_Scene.m_IsoData.MaterialGUID(VCEditor.SelectedVoxelType);
ulong newmat_guid = VCEditor.SelectedMaterial.m_Guid;
if (oldmat_guid != newmat_guid)
{
VCEAlterMaterialMap modify = new VCEAlterMaterialMap(VCEditor.SelectedVoxelType, oldmat_guid, newmat_guid);
m_Action.Modifies.Add(modify);
}
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
IntVector3 min = Min;
IntVector3 max = Max;
for (int x = min.x; x <= max.x; ++x)
{
for (int y = min.y; y <= max.y; ++y)
{
for (int z = min.z; z <= max.z; ++z)
{
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.MirrorVoxel(new IntVector3(x, y, z));
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
// No mirror
else
{
int voxel_pos = VCIsoData.IPosToKey(new IntVector3(x, y, z));
VCVoxel old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
VCVoxel new_voxel = new VCVoxel(255, (byte)VCEditor.SelectedVoxelType);
if (old_voxel != new_voxel)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_voxel, new_voxel);
m_Action.Modifies.Add(modify);
}
}
}
}
}
if (m_Action.Modifies.Count > 0)
{
m_Action.Do();
}
ResetDrawing();
}
public void Update()
{
int sel_count = VCEditor.Instance.m_VoxelSelection.m_Selection.Count;
if (sel_count == 0)
{
m_SelectInfo.text = "[00FFFF]0[-] " + "voxel selected".ToLocalizationString() + ".";
m_FunctionGroup.SetActive(false);
}
else if (sel_count == 1)
{
m_SelectInfo.text = "[00FFFF]1[-] " + "voxel selected".ToLocalizationString() + ".";
m_FunctionGroup.SetActive(true);
}
else if (sel_count < 10000)
{
m_SelectInfo.text = "[00FFFF]" + sel_count.ToString("#,###") + "[-] " + "voxels selected".ToLocalizationString() + ".";
m_FunctionGroup.SetActive(true);
}
else
{
m_SelectInfo.text = "[00FFFF]" + sel_count.ToString("#,###") + "[-]\r\n" + "voxels selected".ToLocalizationString() + ".";
m_FunctionGroup.SetActive(true);
}
if (sel_count == 1)
{
m_VolumeGroup.SetActive(true);
int key = -1;
VCVoxel old_voxel = new VCVoxel();
VCVoxel new_voxel = new VCVoxel();
foreach (KeyValuePair <int, byte> kvp in VCEditor.Instance.m_VoxelSelection.m_Selection)
{
key = kvp.Key;
old_voxel = VCEditor.s_Scene.m_IsoData.GetVoxel(kvp.Key);
}
if (key != oldKey)
{
m_VolModifyAction = null;
oldKey = key;
}
if (key >= 0)
{
if (m_VolModifyAction == null)
{
m_VolModifyAction = new VCEAction();
VolumeSliderValue = old_voxel.VolumeF;
oldVol = VolumeSliderValue;
}
m_VolumeLabel.text = "Voxel volume".ToLocalizationString() + " = [FFFF00]" + (VolumeSliderValue * 200 - 100).ToString("0") + "[-]";
new_voxel = old_voxel;
new_voxel.VolumeF = VolumeSliderValue;
if (Input.GetMouseButtonUp(0) && Mathf.Abs(oldVol - VolumeSliderValue) > 0.002f)
{
oldVol = VolumeSliderValue;
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.MirrorVoxel(VCIsoData.KeyToIPos(key));
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
if (VCEditor.s_Scene.m_IsoData.IsPointIn(VCEditor.s_Mirror.Output[i]))
{
int voxel_pos = VCIsoData.IPosToKey(VCEditor.s_Mirror.Output[i]);
VCVoxel old_v = VCEditor.s_Scene.m_IsoData.GetVoxel(voxel_pos);
if (old_v.Volume == 0)
{
continue;
}
VCVoxel new_v = old_v;
new_v.VolumeF = VolumeSliderValue;
if (m_VolModifyAction.Modifies.Count == 0)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_v, new_v);
m_VolModifyAction.Modifies.Add(modify);
m_VolModifyAction.Do();
}
else
{
bool changed = false;
foreach (VCEModify modify in m_VolModifyAction.Modifies)
{
VCEAlterVoxel avmodify = modify as VCEAlterVoxel;
if (avmodify != null)
{
if (avmodify.m_Pos == voxel_pos)
{
avmodify.m_New = new_v;
changed = true;
}
}
}
if (!changed)
{
VCEAlterVoxel modify = new VCEAlterVoxel(voxel_pos, old_v, new_v);
m_VolModifyAction.Modifies.Add(modify);
}
m_VolModifyAction.DoButNotRegister();
}
}
}
}
// No mirror
else
{
if (m_VolModifyAction.Modifies.Count == 0)
{
VCEAlterVoxel modify = new VCEAlterVoxel(key, old_voxel, new_voxel);
m_VolModifyAction.Modifies.Add(modify);
m_VolModifyAction.Do();
}
else
{
bool changed = false;
foreach (VCEModify modify in m_VolModifyAction.Modifies)
{
VCEAlterVoxel avmodify = modify as VCEAlterVoxel;
if (avmodify != null)
{
if (avmodify.m_Pos == key)
{
avmodify.m_New = new_voxel;
changed = true;
}
}
}
if (!changed)
{
VCEAlterVoxel modify = new VCEAlterVoxel(key, old_voxel, new_voxel);
m_VolModifyAction.Modifies.Add(modify);
}
m_VolModifyAction.DoButNotRegister();
}
}
}
}
}
else
{
m_VolumeGroup.SetActive(false);
m_VolModifyAction = null;
oldKey = -1;
oldVol = 0;
}
if (m_BoxMethodCheck.isChecked)
{
m_SelectBrush.SelectMethod = EVCESelectMethod.Box;
}
// else if ( m_BoxMethodCheck.isChecked )
// {
//
// }
else
{
m_SelectBrush.SelectMethod = EVCESelectMethod.None;
}
if (VCEditor.Instance.m_UI.m_MaterialTab.isChecked)
{
if (VCEditor.SelectedVoxelType >= 0)
{
m_TextureBtnGO.SetActive(true);
}
else
{
m_TextureBtnGO.SetActive(false);
}
m_ColorBtnGO.SetActive(false);
m_EraseBtnGO.SetActive(false);
}
else if (VCEditor.Instance.m_UI.m_PaintTab.isChecked)
{
m_TextureBtnGO.SetActive(false);
m_ColorBtnGO.SetActive(true);
m_EraseBtnGO.SetActive(true);
}
if (m_FunctionGroup.activeSelf)
{
m_FunctionGroup.GetComponent <UIGrid>().Reposition();
}
}
void Update()
{
// Save recent vars
s_RecentRadius = m_Radius;
s_RecentHardness = m_Hardness;
s_RecentStrength = m_Strength;
// Prepare collider
if (!VCEditor.s_Scene.m_MeshComputer.Computing)
{
if (m_MeshMgr.m_ColliderDirty)
{
m_MeshMgr.PrepareMeshColliders();
}
}
if (m_MeshMgr.m_ColliderDirty)
{
return;
}
// Color ( target & display )
m_TargetColor = m_Eraser ? VCIsoData.BLANK_COLOR : VCEditor.SelectedColor;
m_UIColor = m_TargetColor;
m_UIColor.a = 1;
// Update mesh color
foreach (MeshFilter mf in m_NeedUpdateMfs)
{
m_MeshMgr.UpdateMeshColor(mf);
}
m_NeedUpdateMfs.Clear();
// Drawing
if (m_Drawing)
{
if (VCEInput.s_Cancel)
{
m_Drawing = false;
if (m_Action != null)
{
m_Action.Undo();
m_Action = null;
}
else
{
Debug.LogError("There must be some problem");
}
}
else
{
if (Input.GetMouseButtonUp(0))
{
m_Drawing = false;
if (m_Action != null)
{
VCEUpdateColorSign sign_f = new VCEUpdateColorSign(true, false);
m_Action.Modifies.Add(sign_f);
if (m_Action.Modifies.Count > 2)
{
m_Action.Do();
}
m_Action = null;
}
else
{
Debug.LogError("There must be some problem");
}
}
else
{
// Mouse is pressing
// During drawing: From 2nd frame since mouse down
// 1. Test hitpoint now
RaycastHit rch;
Vector3 hit;
if (VCEMath.RayCastMesh(VCEInput.s_PickRay, out rch))
{
hit = rch.point;
m_simDist = rch.distance;
}
else
{
hit = VCEInput.s_PickRay.GetPoint(m_simDist);
}
// 2. Step by step ray cast
Vector3 move_vec = hit - m_lastHit;
if (move_vec.magnitude > m_simStep)
{
float ustep = m_simStep / move_vec.magnitude;
// traverse all the interpolation points
for (float t = ustep; t < 0.999f + ustep; t += ustep)
{
t = Mathf.Clamp01(t);
Vector3 inter_point = m_lastHit + t * move_vec;
Ray test_ray = new Ray(VCEInput.s_PickRay.origin, (inter_point - VCEInput.s_PickRay.origin).normalized);
if (VCEMath.RayCastMesh(test_ray, out rch))
{
m_simDist = rch.distance;
if ((rch.point - m_lastDraw).magnitude > m_drawStep)
{
PaintPosition(rch.point, rch.normal);
m_lastDraw = rch.point;
Debug.DrawRay(test_ray.origin, inter_point - VCEInput.s_PickRay.origin, m_UIColor, 10.0f);
}
else
{
Debug.DrawRay(test_ray.origin, inter_point - VCEInput.s_PickRay.origin, new Color(m_UIColor.r, m_UIColor.g, m_UIColor.b, 0.2f), 10.0f);
}
}
else
{
Debug.DrawRay(test_ray.origin, inter_point - VCEInput.s_PickRay.origin, new Color(m_UIColor.r, m_UIColor.g, m_UIColor.b, 0.1f), 10.0f);
}
}
// 3. Update last hitpoint
m_lastHit = hit;
}
}
}
}
else
{
if (VCEInput.s_Cancel)
{
Cancel();
}
else
{
if (Input.GetMouseButtonDown(0) && !VCEInput.s_MouseOnUI)
{
m_Drawing = true;
if (m_Action != null)
{
Debug.LogError("There must be some problem");
m_Action = null;
}
m_Action = new VCEAction();
VCEUpdateColorSign sign_b = new VCEUpdateColorSign(false, true);
m_Action.Modifies.Add(sign_b);
// draw once
// Init continous drawing vars
m_lastHit = Vector3.zero;
m_lastDraw = Vector3.one * (-100);
m_simStep = Mathf.Clamp(m_Radius * 0.07f, 0.2f, 100.0f) * VCEditor.s_Scene.m_Setting.m_VoxelSize;
m_drawStep = Mathf.Clamp(m_Radius * 0.5f, 0.2f, 100.0f) * VCEditor.s_Scene.m_Setting.m_VoxelSize;
m_simDist = VCEditor.s_Scene.m_Setting.EditorWorldSize.magnitude * 0.2f;
RaycastHit rch;
// cast
if (VCEMath.RayCastMesh(VCEInput.s_PickRay, out rch))
{
PaintPosition(rch.point, rch.normal);
m_lastHit = rch.point;
m_lastDraw = rch.point;
m_simDist = rch.distance;
}
// no cast
else
{
m_lastHit = VCEInput.s_PickRay.GetPoint(m_simDist);
}
}
}
}
}
