public override void Redo()
{
VCComponentData data = VCEditor.s_Scene.m_IsoData.m_Components[m_Index];
data.Import(m_NewData.Export());
data.UpdateEntity(true);
}
public void MirrorComponent(VCComponentData cdata)
{
ComponentOutput[0] = cdata.Copy();
OutputCnt = 1;
if (XPlane_Masked)
{
MirrorComponentOnce(1);
}
if (YPlane_Masked)
{
MirrorComponentOnce(2);
}
if (ZPlane_Masked)
{
MirrorComponentOnce(4);
}
if (XYAxis_Masked)
{
MirrorComponentOnce(3);
}
if (YZAxis_Masked)
{
MirrorComponentOnce(6);
}
if (ZXAxis_Masked)
{
MirrorComponentOnce(5);
}
if (Point_Masked)
{
MirrorComponentOnce(7);
}
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCDecalData;
m_PositionInput.Vector = m_Data.m_Position;
m_RotationInput.Vector = m_Data.m_Rotation;
m_ScaleInput.Vector = new Vector3(m_Data.m_Size, m_Data.m_Size, m_Data.m_Depth);
m_MirroredCheck.isChecked = m_Data.m_Mirrored;
m_ColorPicker.FinalColor = m_Data.m_Color;
if (m_Data.m_ShaderIndex == 0)
{
m_Shader0Check.isChecked = true;
m_Shader1Check.isChecked = false;
}
else if (m_Data.m_ShaderIndex == 1)
{
m_Shader1Check.isChecked = true;
m_Shader0Check.isChecked = false;
}
else
{
m_Shader0Check.isChecked = true;
m_Shader1Check.isChecked = false;
}
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCFixedPartData;
m_PositionInput.Vector = m_Data.m_Position;
m_VisibleCheck.isChecked = m_Data.m_Visible;
}
public override void Undo()
{
VCComponentData data = m_Data.Copy();
data.CreateEntity(true, null);
VCEditor.s_Scene.m_IsoData.m_Components.Insert(m_Index, data);
}
public override void Redo()
{
VCComponentData data = m_Data.Copy();
data.CreateEntity(true, null);
VCEditor.s_Scene.m_IsoData.m_Components.Insert(m_Index, data);
VCESelectComponent.s_LastCreate = data.m_Entity.GetComponent <VCEComponentTool>();
}
public virtual VCComponentData Copy()
{
VCComponentData copydata = Create(m_Type, Export());
copydata.m_Entity = m_Entity;
copydata.m_CurrIso = m_CurrIso;
return(copydata);
}
public override void Redo()
{
VCComponentData data = VCEditor.s_Scene.m_IsoData.m_Components[m_Index];
data.m_Position = m_NewPosition;
data.m_Rotation = m_NewRotation;
data.m_Scale = m_NewScale;
data.UpdateEntity(true);
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCTriphaseFixedPartData;
m_PositionInput.Vector = m_Data.m_Position;
m_VisibleCheck.isChecked = m_Data.m_Visible;
m_Phase0Check.isChecked = (m_Data.m_Phase == 0);
m_Phase1Check.isChecked = (m_Data.m_Phase == 1);
m_Phase2Check.isChecked = (m_Data.m_Phase == 2);
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCObjectLightData;
m_PositionInput.Vector = m_Data.m_Position;
m_RotationInput.Vector = m_Data.m_Rotation;
m_ScaleInput.Vector = m_Data.m_Scale;
m_ColorPicker.FinalColor = m_Data.m_Color;
m_VisibleCheck.isChecked = m_Data.m_Visible;
}
public static VCComponentData Create(EVCComponent type, byte[] buffer)
{
VCComponentData cdata = Create(type);
if (cdata != null)
{
cdata.Import(buffer);
}
return(cdata);
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCQuadphaseFixedPartData;
m_PositionInput.Vector = m_Data.m_Position;
m_VisibleCheck.isChecked = m_Data.m_Visible;
m_Phase0Check.isChecked = (m_Data.m_Phase & 1) == 0;
m_Phase1Check.isChecked = (m_Data.m_Phase & 1) == 1;
m_SmallBigCheck.isChecked = (m_Data.m_Phase & 2) == 2;
m_MotorCheck.isChecked = (m_Data.m_Phase & 4) != 4;
}
public List <VCEComponentTool> MirrorImage(VCEComponentTool c)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
List <VCEComponentTool> list_ret = new List <VCEComponentTool> ();
VCEditor.s_Mirror.MirrorComponent(c.m_Data);
for (int i = 1; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
List <VCComponentData> projections = VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(image.m_Position, image.m_ComponentId);
foreach (VCComponentData iter in projections)
{
if (!VCEMath.IsEqualRotation(iter.m_Rotation, image.m_Rotation))
{
continue;
}
if (iter.m_Scale != image.m_Scale)
{
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;
}
}
VCEComponentTool imct = iter.m_Entity.GetComponent <VCEComponentTool>();
if (imct == null)
{
continue;
}
if (imct == c)
{
continue;
}
list_ret.Add(imct);
}
}
return(list_ret);
}
// No mirror
else
{
return(new List <VCEComponentTool> ());
}
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCObjectPivotData;
m_PositionInput.Vector = m_Data.m_Position;
m_RotationInput.Vector = m_Data.m_Rotation;
m_ScaleInput.Vector = m_Data.m_Scale;
m_VisibleCheck.isChecked = m_Data.m_Visible;
m_AnlgeLable.text = m_Data.m_PivotAng.ToString();
m_AnlgeSlider.sliderValue = Convert.ToSingle(m_Data.m_PivotAng) / 720 + 0.5f;
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCFixedHandPartData;
m_PositionInput.Vector = m_Data.m_Position;
m_RotationInput.Vector = m_Data.m_Rotation;
if (m_VisibleCheck)
{
m_VisibleCheck.isChecked = m_Data.m_Visible;
}
m_Phase0Check.isChecked = m_Data.m_LeftHand;
m_Phase1Check.isChecked = !m_Data.m_LeftHand;
}
// Find Component
public int GetComponentIndex(VCComponentData cdata)
{
if (cdata != null)
{
for (int i = 0; i < m_Components.Count; ++i)
{
if (m_Components[i] == cdata)
{
return(i);
}
}
}
return(-1);
}
public static VCComponentData Create(VCPartInfo part)
{
if (part == null)
{
return(null);
}
VCComponentData data = Create(part.m_Type);
data.m_ComponentId = part.m_ID;
data.m_Type = part.m_Type;
data.m_Position = Vector3.zero;
data.m_Rotation = Vector3.zero;
data.m_Scale = Vector3.one;
data.m_Visible = true;
return(data);
}
void ShowDataInspector(string respath, VCComponentData setdata)
{
HideDataInspector();
m_DataInspector = GameObject.Instantiate(Resources.Load(respath) as GameObject) as GameObject;
m_DataInspector.transform.parent = VCEditor.Instance.m_UI.m_InspectorGroup;
m_DataInspector.transform.localPosition = new Vector3(0, -30, -1f);
m_DataInspector.transform.localScale = Vector3.one;
m_DataInspector.SetActive(true);
VCEUIComponentInspector cins = m_DataInspector.GetComponent <VCEUIComponentInspector>();
cins.m_SelectBrush = this;
cins.Set(setdata);
// Bone Panel
ShowBonePanel();
}
public override void Set(VCComponentData data)
{
data.Validate();
m_Data = data.Copy() as VCGeneralPartData;
m_PositionInput.Vector = m_Data.m_Position;
m_RotationInput.Vector = m_Data.m_Rotation;
m_ArmorPartIndex = m_Data.m_ExtendData;
if (m_VisibleCheck)
{
m_VisibleCheck.isChecked = m_Data.m_Visible;
}
WhiteCat.VCPArmorPivot m_VCPArmorPivot = m_SelectBrush.GetVCPArmorPivotByIndex(m_Data.m_ExtendData);
if (m_VCPArmorPivot)
{
VCEditor.Instance.m_UI.bonePanel.Show(m_VCPArmorPivot);
}
}
void OnSelectionChange()
{
s_LastCreate = null;
if (m_Selection.Count == 1)
{
VCComponentData sel_data = m_Selection[0].m_Component.m_Data;
VCPartData sel_part_data = sel_data as VCPartData;
VCDecalData sel_decal_data = sel_data as VCDecalData;
if (sel_part_data != null)
{
ShowDataInspector(VCConfig.s_PartTypes[sel_part_data.m_Type].m_InspectorRes, sel_data);
}
else if (sel_decal_data != null)
{
ShowDataInspector("GUI/Prefabs/Inspectors/Components Inspectors/inspector decal image", sel_data);
}
}
if (m_Selection.Count > 0)
{
VCEStatusBar.ShowText(m_Selection.Count.ToString() + " " + "component(s)".ToLocalizationString() + " " + "selected".ToLocalizationString(), 4);
}
}
private void MirrorComponentOnce(int mirror)
{
for (int i = 0; i < OutputCnt; ++i)
{
VCComponentData real = ComponentOutput[i];
VCComponentData image = ComponentOutput[i].Copy();
ComponentOutput[i + OutputCnt] = image;
image.m_Position.x = ((mirror & 1) > 0) ? (2.0f * m_WorldPosX - real.m_Position.x) : (real.m_Position.x);
image.m_Position.y = ((mirror & 2) > 0) ? (2.0f * m_WorldPosY - real.m_Position.y) : (real.m_Position.y);
image.m_Position.z = ((mirror & 4) > 0) ? (2.0f * m_WorldPosZ - real.m_Position.z) : (real.m_Position.z);
bool xsym = true;
if (image is VCPartData)
{
xsym = (VCConfig.s_Parts[image.m_ComponentId].m_Symmetric == 1);
}
if (image is VCDecalData)
{
xsym = true;
}
if (xsym)
{
if ((mirror & 1) > 0)
{
//image.m_Rotation.x = image.m_Rotation.x;
image.m_Rotation.y = -image.m_Rotation.y;
image.m_Rotation.z = -image.m_Rotation.z;
if (image is IVCMultiphaseComponentData)
{
(image as IVCMultiphaseComponentData).InversePhase();
}
}
if ((mirror & 2) > 0)
{
image.m_Rotation.x = -image.m_Rotation.x;
//image.m_Rotation.y = image.m_Rotation.y;
image.m_Rotation.z = 180f - image.m_Rotation.z;
if (image is IVCMultiphaseComponentData)
{
(image as IVCMultiphaseComponentData).InversePhase();
}
}
if ((mirror & 4) > 0)
{
//image.m_Rotation.x = image.m_Rotation.x;
image.m_Rotation.y = 180f - image.m_Rotation.y;
image.m_Rotation.z = -image.m_Rotation.z;
if (image is IVCMultiphaseComponentData)
{
(image as IVCMultiphaseComponentData).InversePhase();
}
}
}
else
{
if ((mirror & 1) > 0)
{
if (image is IVCMultiphaseComponentData)
{
(image as IVCMultiphaseComponentData).InversePhase();
}
}
}
image.m_Rotation = VCEMath.NormalizeEulerAngle(image.m_Rotation);
}
OutputCnt = OutputCnt << 1;
}
public bool Import(byte[] buffer, VAOption options)
{
if (buffer == null)
{
return(false);
}
Reset(options);
int min_iso_size = 48;
if (buffer.Length < min_iso_size)
{
return(false);
}
using (MemoryStream ms_iso = new MemoryStream(buffer))
{
BinaryReader r = new BinaryReader(ms_iso);
// Header
string check_str = r.ReadString(); // r, string
if (check_str != "VCISO")
{
r.Close();
return(false);
}
int l = 0;
m_HeadInfo.Version = r.ReadInt32(); // r, int
m_HeadInfo.Category = (EVCCategory)(r.ReadInt32()); // r, int
string author = "";
if (m_HeadInfo.Version >= 0x02020000)
{
author = r.ReadString();
}
m_HeadInfo.Name = r.ReadString(); // r, string
m_HeadInfo.Desc = r.ReadString(); // r, string
string remarks = "";
if (m_HeadInfo.Version >= 0x02020000)
{
remarks = r.ReadString();
}
m_HeadInfo.xSize = r.ReadInt32(); // r, int
m_HeadInfo.ySize = r.ReadInt32(); // r, int
m_HeadInfo.zSize = r.ReadInt32(); // r, int
l = r.ReadInt32(); // r, int
m_HeadInfo.IconTex = r.ReadBytes(l); // r, byte[]
//m_HeadInfo.EnsureIconTexValid();
m_HeadInfo.Author = "";
m_HeadInfo.Remarks = "";
if (m_HeadInfo.Version >= 0x02020000)
{
for (int c = 0; c < author.Length; ++c)
{
m_HeadInfo.Author += (char)(author[c] ^ (char)(0xAC));
}
for (int c = 0; c < remarks.Length; ++c)
{
m_HeadInfo.Remarks += (char)(remarks[c] ^ (char)(0xAC));
}
}
switch (m_HeadInfo.Version)
{
case 0x02000000:
case 0x02010000:
case 0x02020000:
case 0x02020001:
{
// Counts
int mat_cnt = r.ReadInt32(); // r, int
int dcl_cnt = 0;
if (m_HeadInfo.Version >= 0x02010000)
{
dcl_cnt = r.ReadInt32(); // r, int
}
int com_cnt = r.ReadInt32(); // r, int
int vxl_cnt = r.ReadInt32(); // r, int
int clr_cnt = r.ReadInt32(); // r, int
// Materials
for (int i = 0; i < mat_cnt; ++i)
{
ulong guid = r.ReadUInt64(); // r, ulong;
if (guid != 0)
{
l = r.ReadInt32(); // r, int
byte[] mat_buffer = r.ReadBytes(l); // r, byte[]
// Option
// If for editor, find mats in VCEAssetMgr for the iso, or create mats in VCEAssetMgr.
if (m_Options.ForEditor)
{
//if ( VCEAssetMgr.s_Materials.ContainsKey(guid) )
//{
// m_Materials[i] = VCEAssetMgr.s_Materials[guid];
//}
//else
//{
// VAMaterial vcmat = new VAMaterial ();
// vcmat.Import(mat_buffer);
// VCEAssetMgr.s_TempMaterials.Add(guid, vcmat);
// m_Materials[i] = vcmat;
//}
}
// If not for editor, these materials are belong to the iso.
else
{
m_Materials[i] = new VAMaterial();
m_Materials[i].Import(mat_buffer);
}
}
}
// Decals
for (int i = 0; i < dcl_cnt; ++i)
{
ulong guid = r.ReadUInt64(); // r, ulong;
if (guid != 0)
{
l = r.ReadInt32(); // r, int
byte[] dcl_buffer = r.ReadBytes(l); // r, byte[]
// Option
// If for editor, find decals in VCEAssetMgr for the iso, or create decals in VCEAssetMgr.
if (m_Options.ForEditor)
{
if (VCEAssetMgr.s_Decals.ContainsKey(guid))
{
m_DecalAssets[i] = VCEAssetMgr.s_Decals[guid];
}
else
{
VCDecalAsset vcdcl = new VCDecalAsset();
vcdcl.Import(dcl_buffer);
VCEAssetMgr.s_TempDecals.Add(guid, vcdcl);
m_DecalAssets[i] = vcdcl;
}
}
// If not for editor, these decals are belong to the iso.
else
{
m_DecalAssets[i] = new VCDecalAsset();
m_DecalAssets[i].Import(dcl_buffer);
}
}
}
// Read compressed data
//
using (MemoryStream ms_zip = new MemoryStream())
{
l = r.ReadInt32(); // r, int
ms_zip.Write(r.ReadBytes(l), 0, l); // r, byte[] zip, byte[]
// Decompress data
//
using (MemoryStream ms_unzip = new MemoryStream())
{
ms_zip.Seek((long)(0), SeekOrigin.Begin);
IonicZlib.Decompress(ms_zip, ms_unzip);
ms_unzip.Seek((long)(0), SeekOrigin.Begin);
BinaryReader r_unzip = new BinaryReader(ms_unzip);
// Components
for (int i = 0; i < com_cnt; ++i)
{
l = r_unzip.ReadInt32(); // unzip, int
if (l > 0)
{
byte[] com_buffer = r_unzip.ReadBytes(l); // unzip, byte[]
EVCComponent com_type = (EVCComponent)(r_unzip.ReadInt32()); // unzip, int
VCComponentData cdata = VCComponentData.Create(com_type, com_buffer);
if (cdata != null)
{
//cdata.m_CurrIso = this;
m_Components.Add(cdata);
}
}
}
if (m_HeadInfo.Version >= 0x02020001)
{
ulong sig = r_unzip.ReadUInt64();
if (m_HeadInfo.HeadSignature != sig)
{
Debug.LogError("Check sig failed");
return(false);
}
}
// Voxels
for (int i = 0; i < vxl_cnt; ++i)
{
int key = r_unzip.ReadInt32(); // unzip, int
ushort val = r_unzip.ReadUInt16(); // unzip, ushort
m_Voxels[key] = (VCVoxel)(val);
}
// Colors
for (int i = 0; i < clr_cnt; ++i)
{
int key = r_unzip.ReadInt32(); // unzip, int
Color32 val;
val.r = r_unzip.ReadByte(); // unzip, byte
val.g = r_unzip.ReadByte(); // unzip, byte
val.b = r_unzip.ReadByte(); // unzip, byte
val.a = r_unzip.ReadByte(); // unzip, byte
m_Colors.Add(key, val);
}
r_unzip.Close();
}
}
break;
}
default: return(false);
}
r.Close();
return(true);
}
}
public VCEAlterComponent(int index, VCComponentData old_data, VCComponentData new_data)
{
m_Index = index;
m_OldData = old_data.Copy();
m_NewData = new_data.Copy();
}
// Moving Gizmo
void OnMoving(Vector3 offset)
{
float hvs = VCEditor.s_Scene.m_Setting.m_VoxelSize * 0.5f;
VCEditor.s_Mirror.CalcPrepare(hvs * 2);
foreach (SelectInfo si in m_Selection)
{
si.m_DragPosition += offset;
si.m_NewPosition.x = Mathf.Round(si.m_DragPosition.x / hvs) * hvs;
si.m_NewPosition.y = Mathf.Round(si.m_DragPosition.y / hvs) * hvs;
si.m_NewPosition.z = Mathf.Round(si.m_DragPosition.z / hvs) * hvs;
Vector3 tmp_pos = si.m_Component.m_Data.m_Position;
si.m_Component.m_Data.m_Position = si.m_NewPosition;
si.m_Component.m_Data.Validate();
si.m_NewPosition = si.m_Component.transform.position = si.m_Component.m_Data.m_Position;
if (m_DataInspector != null)
{
m_DataInspector.GetComponent <VCEUIComponentInspector>().Set(si.m_Component.m_Data);
}
si.m_Component.m_Data.m_Position = tmp_pos;
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
Vector3[] old_poses = 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;
}
VCComponentData tmpdata = si.m_Component.m_Data.Copy();
tmpdata.m_Position = si.m_NewPosition;
VCEditor.s_Mirror.MirrorComponent(tmpdata);
for (int i = 1; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
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, image.m_Rotation))
{
continue;
}
if (iter.m_Scale != image.m_Scale)
{
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)
{
iter.m_Entity.transform.position = image.m_Position;
}
}
}
}
// End 'mirror'
}
}
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");
}
}
void OnRotating(Vector3 axis, float angle)
{
float hvs = VCEditor.s_Scene.m_Setting.m_VoxelSize * 0.5f;
VCEditor.s_Mirror.CalcPrepare(hvs * 2);
foreach (SelectInfo si in m_Selection)
{
Vector3 cached_rot = si.m_Component.transform.eulerAngles;
si.m_Component.transform.eulerAngles = si.m_OldRotation;
si.m_Component.transform.Rotate(axis, angle, Space.World);
si.m_DragRotation = si.m_Component.transform.eulerAngles;
si.m_DragRotation = VCEMath.NormalizeEulerAngle(si.m_DragRotation);
si.m_NewRotation = si.m_DragRotation;
si.m_Component.transform.eulerAngles = cached_rot;
Vector3 tmp_rot = si.m_Component.m_Data.m_Rotation;
si.m_Component.m_Data.m_Rotation = si.m_NewRotation;
si.m_Component.m_Data.Validate();
if (si.m_Component.m_Data.m_Rotation != si.m_NewRotation)
{
si.m_NewRotation = cached_rot;
si.m_Component.m_Data.m_Rotation = si.m_NewRotation;
si.m_Component.m_Data.Validate();
}
si.m_NewRotation = si.m_Component.transform.eulerAngles = si.m_Component.m_Data.m_Rotation;
if (m_DataInspector != null)
{
m_DataInspector.GetComponent <VCEUIComponentInspector>().Set(si.m_Component.m_Data);
}
si.m_Component.m_Data.m_Rotation = tmp_rot;
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
Vector3[] old_rots = new Vector3[8];
VCEditor.s_Mirror.MirrorComponent(si.m_Component.m_Data);
for (int i = 0; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
old_rots[i] = VCEditor.s_Mirror.ComponentOutput[i].m_Rotation;
}
VCComponentData tmpdata = si.m_Component.m_Data.Copy();
tmpdata.m_Rotation = si.m_NewRotation;
VCEditor.s_Mirror.MirrorComponent(tmpdata);
for (int i = 1; i < VCEditor.s_Mirror.OutputCnt; ++i)
{
VCComponentData image = VCEditor.s_Mirror.ComponentOutput[i];
List <VCComponentData> edits = VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(image.m_Position, image.m_ComponentId);
foreach (VCComponentData iter in edits)
{
if (!VCEMath.IsEqualRotation(iter.m_Rotation, old_rots[i]))
{
continue;
}
if (iter.m_Scale != image.m_Scale)
{
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)
{
iter.m_Entity.transform.eulerAngles = image.m_Rotation;
}
}
}
}
// End 'mirror'
}
}
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();
}
public VCEDelComponent(int index, VCComponentData data)
{
m_Index = index;
m_Data = data.Copy();
}
public abstract void Set(VCComponentData data);
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 ?");
}
}
