public override void UpdateEntity(bool for_editor)
{
if (for_editor)
{
VCEComponentTool tool = m_Entity.GetComponent <VCEComponentTool>();
tool.m_Data = this;
}
m_Rotation = VCEMath.NormalizeEulerAngle(m_Rotation);
m_Entity.transform.localPosition = m_Position;
m_Entity.transform.localEulerAngles = m_Rotation;
m_Entity.transform.localScale = m_Scale;
VCDecalHandler dh = m_Entity.GetComponent <VCDecalHandler>();
if (for_editor)
{
dh.m_Guid = m_Guid;
dh.m_Iso = null;
dh.m_AssetIndex = -1;
}
else
{
dh.m_Guid = 0;
dh.m_Iso = m_CurrIso;
dh.m_AssetIndex = m_AssetIndex;
}
dh.m_Size = m_Size;
dh.m_Depth = m_Depth;
dh.m_Mirrored = m_Mirrored;
dh.m_ShaderIndex = m_ShaderIndex;
dh.m_Color = m_Color;
}
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> ());
}
}
// Update is called once per frame
void Update()
{
VCEComponentTool ctool = VCUtils.GetComponentOrOnParent <VCEComponentTool>(this.gameObject);
if (ctool != null)
{
GetComponent <Renderer>().enabled = ctool.m_InEditor;
}
else
{
GameObject.Destroy(this.gameObject);
}
}
void ToggleComponentColliders(bool _enabled)
{
if (!VCEditor.DocumentOpen())
{
return;
}
foreach (VCComponentData cd in VCEditor.s_Scene.m_IsoData.m_Components)
{
VCEComponentTool c = cd.m_Entity.GetComponent <VCEComponentTool>();
c.m_SelBound.enabled = _enabled;
c.m_SelBound.GetComponent <Collider>().enabled = _enabled;
}
}
void OnDestroy()
{
ClearSelection();
ToggleComponentColliders(false);
if (m_MainInspector != null)
{
GameObject.Destroy(m_MainInspector);
m_MainInspector = null;
}
HideDataInspector();
s_LastCreate = null;
VCEditor.s_ProtectLock0 = false;
}
public SelectInfo FindSelected(VCEComponentTool ct)
{
if (ct == null)
{
return(null);
}
foreach (SelectInfo si in m_Selection)
{
if (si.m_Component == ct)
{
return(si);
}
}
return(null);
}
public override void UpdateEntity(bool for_editor)
{
if (for_editor)
{
VCEComponentTool tool = m_Entity.GetComponent <VCEComponentTool>();
tool.m_Data = this;
}
m_Rotation = VCEMath.NormalizeEulerAngle(m_Rotation);
m_Entity.transform.localPosition = m_Position;
m_Entity.transform.localEulerAngles = m_Rotation;
m_Entity.transform.localScale = m_Scale;
VCPSimpleLight func = m_Entity.GetComponent <VCPSimpleLight>();
if (func != null)
{
func.color = m_Color;
}
Renderer[] rs = m_Entity.GetComponentsInChildren <Renderer>(true);
foreach (Renderer r in rs)
{
if (r is TrailRenderer)
{
r.enabled = true;
}
else if (r is ParticleRenderer)
{
r.enabled = true;
}
else if (r is ParticleSystemRenderer)
{
r.enabled = true;
}
else if (r is LineRenderer)
{
r.enabled = true;
}
else if (r is SpriteRenderer)
{
r.enabled = true;
}
else
{
r.enabled = m_Visible;
}
}
}
public override void UpdateEntity(bool for_editor)
{
if (for_editor)
{
VCEComponentTool tool = m_Entity.GetComponent <VCEComponentTool>();
tool.m_Data = this;
}
//m_Rotation = VCEMath.NormalizeEulerAngle(m_Rotation);
m_Rotation = Vector3.zero;
m_Entity.transform.localPosition = m_Position;
m_Entity.transform.localEulerAngles = m_Rotation;
m_Entity.transform.localScale = m_Scale;
VCPPivot func = m_Entity.gameObject.GetComponent <VCPPivot>();
func.Angle = m_PivotAng;
Renderer[] rs = m_Entity.GetComponentsInChildren <Renderer>(true);
foreach (Renderer r in rs)
{
if (r is TrailRenderer)
{
r.enabled = true;
}
else if (r is ParticleRenderer)
{
r.enabled = true;
}
else if (r is ParticleSystemRenderer)
{
r.enabled = true;
}
else if (r is LineRenderer)
{
r.enabled = true;
}
else if (r is SpriteRenderer)
{
r.enabled = true;
}
else
{
r.enabled = m_Visible;
}
}
}
public override GameObject CreateEntity(bool for_editor, Transform parent)
{
if (m_Entity != null)
{
DestroyEntity();
}
m_Entity = GameObject.Instantiate(Resources.Load(s_DecalPrefabPath) as GameObject) as GameObject;
m_Entity.name = "Decal Image";
if (for_editor)
{
m_Entity.transform.parent = VCEditor.Instance.m_DecalGroup.transform;
VCEComponentTool tool = m_Entity.GetComponent <VCEComponentTool>();
tool.m_IsBrush = false;
tool.m_InEditor = true;
tool.m_ToolGroup.SetActive(true);
tool.m_SelBound.enabled = false;
tool.m_SelBound.GetComponent <Collider>().enabled = false;
tool.m_SelBound.m_BoundColor = GLComponentBound.s_Blue;
tool.m_Data = this;
Collider[] cs = m_Entity.GetComponentsInChildren <Collider>(true);
foreach (Collider c in cs)
{
if (c.gameObject != tool.m_SelBound.gameObject)
{
c.enabled = false;
}
}
}
else
{
m_Entity.transform.parent = parent;
Transform[] trs = m_Entity.GetComponentsInChildren <Transform>(true);
foreach (Transform t in trs)
{
t.gameObject.layer = VCConfig.s_ProductLayer;
}
}
UpdateEntity(for_editor);
if (!for_editor)
{
UpdateComponent();
}
return(m_Entity);
}
void NormalizeSelection()
{
SelectInfo del_si = null;
bool changed = false;
do
{
foreach (SelectInfo si in m_Selection)
{
VCEComponentTool ct = si.m_Component;
List <VCEComponentTool> images = MirrorImage(ct);
foreach (VCEComponentTool image in images)
{
del_si = m_Selection.Find(iter => iter.m_Component == image);
if (del_si != null)
{
changed = true;
goto DEL;
}
}
}
DEL:
m_Selection.Remove(del_si);
}while (del_si != null);
List <SelectInfo> del_list = new List <SelectInfo> ();
foreach (SelectInfo si in m_Selection)
{
if (si.m_Component == null)
{
del_list.Add(si);
changed = true;
}
}
foreach (SelectInfo si in del_list)
{
m_Selection.Remove(si);
}
if (changed)
{
OnSelectionChange();
}
}
// 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;
}
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);
}
}
void OnEnable()
{
float voxel_size = VCEditor.s_Scene.m_Setting.m_VoxelSize;
if (m_DecalInst != null)
{
GameObject.Destroy(m_DecalInst.gameObject);
m_DecalInst = null;
}
m_DecalInst = (GameObject.Instantiate(m_DecalPrefab) as GameObject).GetComponent <VCDecalHandler>();
m_DecalInst.gameObject.SetActive(false);
m_DecalInst.transform.parent = this.transform;
m_DecalInst.transform.localPosition = Vector3.zero;
m_DecalInst.transform.localScale = Vector3.one;
m_DecalInst.m_Guid = VCEditor.SelectedDecalGUID;
m_DecalInst.m_Depth = voxel_size;
m_DecalInst.m_Size = voxel_size * 10;
m_DecalInst.m_Mirrored = false;
m_DecalInst.m_ShaderIndex = 0;
m_Tool = m_DecalInst.GetComponent <VCEComponentTool>();
m_Tool.m_IsBrush = true;
m_Tool.m_InEditor = true;
m_Tool.m_ToolGroup.SetActive(true);
}
void Update()
{
if (VCEditor.SelectedPart == null)
{
return;
}
if (VCEInput.s_Cancel)
{
Cancel();
return;
}
if (VCEditor.SelectedPart != m_LastSelectedPart)
{
if (m_PartInst != null)
{
GameObject.Destroy(m_PartInst);
}
if (VCEditor.SelectedPart.m_ResObj == null)
{
Debug.LogError("This part has no prefab resource: " + VCEditor.SelectedPart.m_Name);
Cancel();
return;
}
m_PartInst = GameObject.Instantiate(VCEditor.SelectedPart.m_ResObj) as GameObject;
m_PartInst.SetActive(false);
m_PartInst.transform.parent = this.transform;
m_PartInst.transform.localPosition = Vector3.zero;
m_Tool = m_PartInst.GetComponent <VCEComponentTool>();
m_Tool.m_IsBrush = true;
m_Tool.m_InEditor = true;
m_Tool.m_ToolGroup.SetActive(true);
Collider[] cs = m_PartInst.GetComponentsInChildren <Collider>(true);
foreach (Collider c in cs)
{
if (c.gameObject != m_Tool.m_ToolGroup.gameObject)
{
Collider.Destroy(c);
}
else
{
c.enabled = false;
}
}
m_LastSelectedPart = VCEditor.SelectedPart;
}
float voxel_size = VCEditor.s_Scene.m_Setting.m_VoxelSize;
if (!VCEInput.s_MouseOnUI && VCEMath.RayCastDrawTarget(VCEInput.s_PickRay, out m_Target, VCEMath.MC_ISO_VALUE) && VCEditor.s_Scene.m_IsoData.IsPointIn(m_Target.cursor))
{
m_PartInst.SetActive(true);
Vector3 point = m_Target.rch.point * 2;
IntVector3 ipoint = new IntVector3(point);
m_Tool.SetPivotPos(ipoint.ToVector3() * 0.5f * voxel_size);
bool canput = true;
if (VCEditor.s_Scene.m_IsoData.FindComponentsAtPos(m_PartInst.transform.localPosition).Count > 0)
{
canput = false;
}
// Mirror
if (VCEditor.s_Mirror.Enabled_Masked)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
if (m_PartInst.transform.localPosition.x == VCEditor.s_Mirror.WorldPos.x && VCEditor.s_Mirror.XPlane_Masked)
{
canput = false;
}
if (m_PartInst.transform.localPosition.y == VCEditor.s_Mirror.WorldPos.y && VCEditor.s_Mirror.YPlane_Masked)
{
canput = false;
}
if (m_PartInst.transform.localPosition.z == VCEditor.s_Mirror.WorldPos.z && VCEditor.s_Mirror.ZPlane_Masked)
{
canput = false;
}
}
if (canput)
{
m_Tool.m_SelBound.m_BoundColor = GLComponentBound.s_Green;
m_Tool.m_SelBound.m_Highlight = false;
}
else
{
m_Tool.m_SelBound.m_BoundColor = GLComponentBound.s_Red;
m_Tool.m_SelBound.m_Highlight = true;
}
if (Input.GetMouseButtonDown(0) && canput)
{
Do();
}
}
else
{
m_PartInst.SetActive(false);
}
}
void Update()
{
if (!VCEditor.DocumentOpen())
{
return;
}
// Check 's_LastCreate'
if (s_LastCreate != null)
{
ClearSelection();
SelectInfo si = new SelectInfo();
si.m_Component = s_LastCreate;
m_Selection.Add(si);
OnSelectionChange();
}
VCEditor.s_ProtectLock0 = UsingGizmo;
NormalizeSelection();
// Update Pick Order
Vector3 mousePos = Input.mousePosition;
if ((mousePos - lastMousePos).magnitude > 3.1f)
{
pick_order = 0;
lastMousePos = mousePos;
}
#region PART_DESC
// Part Description Board
if (m_DescBoard != null)
{
m_DescBoard.m_Position = Vector3.Lerp(m_DescBoard.m_Position, VCEInput.s_PickRay.GetPoint(1.5f), 0.5f);
List <VCEComponentTool> pickall = new List <VCEComponentTool> ();
if (!UsingGizmo && !VCEInput.s_MouseOnUI)
{
pickall = VCEMath.RayPickComponents(VCEInput.s_PickRay);
}
List <VCPart> pps = new List <VCPart> ();
Vector3 v = Vector3.zero;
if (pickall.Count > 0)
{
v = pickall[0].transform.localPosition;
}
foreach (VCEComponentTool ct in pickall)
{
if (Vector3.Distance(ct.transform.localPosition, v) > VCEditor.s_Scene.m_Setting.m_VoxelSize * 2)
{
continue;
}
VCPart pp = ct.GetComponent <VCPart>();
if (pp != null)
{
pps.Add(pp);
}
}
if (pickall.Count > 0)
{
m_DescBoard.FadeIn();
VCEditor.Instance.m_UI.m_HoloBoardCamera.enabled = true;
}
else
{
VCEditor.Instance.m_UI.m_HoloBoardCamera.enabled = false;
m_DescBoard.FadeOut();
}
pickall.Clear();
VCEditor.Instance.m_UI.m_PartDescList.SyncList(pps);
pps.Clear();
pickall = null;
pps = null;
}
#endregion
// Pick Component
VCEComponentTool picked = null;
if (!VCEInput.s_MouseOnUI && !m_MouseOnGizmo)
{
picked = VCEMath.RayPickComponent(VCEInput.s_PickRay, pick_order);
}
if (Input.GetMouseButtonDown(0) && !VCEInput.s_MouseOnUI && !m_MouseOnGizmo)
{
if (!VCEInput.s_Shift && !VCEInput.s_Control && !VCEInput.s_Alt)
{
m_Selection.Clear();
}
if (picked != null)
{
SelectInfo si = FindSelected(picked);
if (si != null)
{
m_Selection.Remove(si);
}
else
{
si = new SelectInfo();
si.m_Component = picked;
List <SelectInfo> del_list = new List <SelectInfo> ();
foreach (SelectInfo sel in m_Selection)
{
VCEComponentTool ct = sel.m_Component;
List <VCEComponentTool> images = MirrorImage(ct);
if (images.Contains(si.m_Component))
{
del_list.Add(sel);
}
}
m_Selection.Add(si);
foreach (SelectInfo del in del_list)
{
m_Selection.Remove(del);
}
}
pick_order++;
}
OnSelectionChange();
}
// Update bound color & highlight
foreach (VCComponentData cd in VCEditor.s_Scene.m_IsoData.m_Components)
{
VCEComponentTool c = cd.m_Entity.GetComponent <VCEComponentTool>();
c.m_SelBound.enabled = true;
c.m_SelBound.GetComponent <Collider>().enabled = true;
c.m_SelBound.m_Highlight = (c == picked);
c.m_SelBound.m_BoundColor = GLComponentBound.s_Blue;
}
// Update selection and mirror's bound color
if (m_Selection.Count > 0)
{
VCEditor.s_Mirror.CalcPrepare(VCEditor.s_Scene.m_Setting.m_VoxelSize);
foreach (SelectInfo si in m_Selection)
{
VCEComponentTool c = si.m_Component;
List <VCEComponentTool> mirrors = MirrorImage(c);
foreach (VCEComponentTool m in mirrors)
{
m.m_SelBound.m_BoundColor = GLComponentBound.s_Orange;
}
}
foreach (SelectInfo si in m_Selection)
{
VCEComponentTool c = si.m_Component;
c.m_SelBound.m_BoundColor = GLComponentBound.s_Yellow;
}
}
// Update Inspectors
if (m_Selection.Count < 1)
{
HideInspectors();
}
else if (m_Selection.Count == 1)
{
ShowMainInspector();
VCEUISelectComponentInspector sci = m_MainInspector.GetComponent <VCEUISelectComponentInspector>();
if (m_Selection[0].m_Component != null)
{
sci.m_SelectInfo.text = m_Selection[0].m_Component.gameObject.name;
}
else
{
sci.m_SelectInfo.text = "< Deleted >";
}
}
else
{
ShowMainInspector();
HideDataInspector();
VCEUISelectComponentInspector sci = m_MainInspector.GetComponent <VCEUISelectComponentInspector>();
sci.m_SelectInfo.text = m_Selection.Count.ToString() + " " + "objects".ToLocalizationString() + " " + "selected".ToLocalizationString();
}
// Transform Gizmos
if (m_Selection.Count > 0)
{
Vector3 avePos = Vector3.zero;
int rotmask = 7;
foreach (SelectInfo si in m_Selection)
{
avePos += si.m_Component.transform.position;
VCPartData part_data = si.m_Component.m_Data as VCPartData;
if (part_data != null)
{
rotmask &= VCConfig.s_PartTypes[si.m_Component.m_Data.m_Type].m_RotateMask;
}
}
avePos /= ((float)m_Selection.Count);
m_MovingGizmo.transform.position = avePos;
m_RotatingGizmo.transform.position = avePos;
m_MovingGizmo.gameObject.SetActive(VCEditor.TransformType == EVCETransformType.Move);
m_RotatingGizmo.gameObject.SetActive(VCEditor.TransformType == EVCETransformType.Rotate);
m_RotatingGizmo.m_AxisMask = rotmask;
}
else
{
m_MovingGizmo.gameObject.SetActive(false);
m_RotatingGizmo.gameObject.SetActive(false);
}
}
