// Update is called once per frame
void Update()
{
if (VCERefPlane.XRef > 0)
{
m_XRefTrans.gameObject.SetActive(true);
}
else
{
m_XRefTrans.gameObject.SetActive(false);
}
if (VCERefPlane.YRef > 0)
{
m_YRefTrans.gameObject.SetActive(true);
m_BasePlane.m_ShowGrid = false;
}
else
{
m_YRefTrans.gameObject.SetActive(false);
m_BasePlane.m_ShowGrid = true;
}
if (VCERefPlane.ZRef > 0)
{
m_ZRefTrans.gameObject.SetActive(true);
}
else
{
m_ZRefTrans.gameObject.SetActive(false);
}
float voxelsize = (VCEditor.DocumentOpen()) ? (VCEditor.s_Scene.m_Setting.m_VoxelSize) : (0.01f);
m_XRefTrans.localPosition = Vector3.right * (VCERefPlane.XRef * voxelsize);
m_YRefTrans.localPosition = Vector3.up * (VCERefPlane.YRef * voxelsize);
m_ZRefTrans.localPosition = Vector3.forward * (VCERefPlane.ZRef * voxelsize);
}
public override void Cancel()
{
if (VCEditor.DocumentOpen())
{
VCEditor.Instance.m_UI.m_DefaultBrush_Material.isChecked = true;
}
}
// Update is called once per frame
void Update()
{
if (VCEditor.DocumentOpen())
{
SetVoxelSize(VCEditor.s_Scene.m_Setting.m_VoxelSize);
}
}
public static bool RayAdjustHeight(Ray ray, Vector3 basepoint, out float height)
{
height = basepoint.y;
if (!VCEditor.DocumentOpen())
{
return(false);
}
ray = VCEMath.TransformRayToIsoCoord(ray);
if (Mathf.Abs(ray.direction.x) < 0.001f && Mathf.Abs(ray.direction.z) < 0.001f)
{
return(false);
}
else
{
Vector3 horz = Vector3.Cross(Vector3.up, ray.direction).normalized;
Plane ray_plane = new Plane(ray.origin, ray.GetPoint(10), ray.origin + horz * 10);
Ray vert = new Ray(basepoint + Vector3.up * 2000, Vector3.down);
float enter = 0;
if (ray_plane.Raycast(vert, out enter))
{
height = vert.GetPoint(enter).y;
return(true);
}
else
{
return(false);
}
}
}
// Update is called once per frame
void Update()
{
if (VCEditor.DocumentOpen())
{
int index = VCEditor.s_Scene.m_IsoData.QueryMaterialIndex(m_Material);
if (index >= 0 && VCEditor.s_Scene.m_IsoData.m_Materials[index] == m_Material)
{
m_IndexLabel.text = "No." + (index + 1).ToString();
m_IndexLabel.color = Color.white;
}
else if (VCEditor.SelectedMaterial == m_Material)
{
if (VCEditor.SelectedVoxelType < 0)
{
m_IndexLabel.text = "ISO FULL";
m_IndexLabel.color = Color.red;
}
else
{
m_IndexLabel.text = "No." + (VCEditor.SelectedVoxelType + 1).ToString();
m_IndexLabel.color = Color.white;
}
}
else
{
m_IndexLabel.text = "";
m_IndexLabel.color = Color.white;
}
bool tempmat = VCEAssetMgr.s_TempMaterials.ContainsKey(m_Material.m_Guid);
bool existmat = VCEAssetMgr.s_Materials.ContainsKey(m_Material.m_Guid);
m_AddBtn.SetActive(tempmat && !existmat);
m_DelBtn.SetActive(!tempmat && existmat && index < 0 && VCEditor.SelectedMaterial == m_Material);
}
}
// Update is called once per frame
void LateUpdate()
{
VCDecalAsset decal_asset = VCEAssetMgr.GetDecal(m_Guid);
if (decal_asset == null)
{
if (m_Iso != null && m_Iso.m_DecalAssets != null && m_AssetIndex >= 0 && m_AssetIndex < VCIsoData.DECAL_ARR_CNT)
{
decal_asset = m_Iso.m_DecalAssets[m_AssetIndex];
}
}
if (decal_asset == null)
{
m_Projector.gameObject.SetActive(false);
return;
}
if (VCEditor.DocumentOpen() && m_Tool != null && m_Tool.m_SelBound != null)
{
m_Tool.m_SelBound.transform.localScale = new Vector3(m_Size, m_Size, m_Depth * 2 - 0.002f);
m_Tool.m_SelBound.transform.localPosition = new Vector3(0, 0, 0);
}
Material usedMaterial = null;
if (m_ShaderIndex >= 0 && m_ShaderIndex < m_DecalMats.Length)
{
usedMaterial = m_DecalMats[m_ShaderIndex];
}
m_Projector.gameObject.SetActive(usedMaterial != null);
if (usedMaterial != null)
{
m_Projector.material = usedMaterial;
m_Projector.nearClipPlane = 0.001f - m_Depth;
m_Projector.farClipPlane = m_Depth - 0.001f;
m_Projector.orthographicSize = m_Size * 0.5f;
usedMaterial.SetTexture("_Texture", decal_asset.m_Tex);
usedMaterial.SetColor("_TintColor", m_Color);
usedMaterial.SetFloat("_Size", m_Size * 0.5f);
usedMaterial.SetFloat("_Depth", m_Depth);
usedMaterial.SetVector("_Center", new Vector4(transform.position.x, transform.position.y, transform.position.z, 1));
usedMaterial.SetVector("_Forward", new Vector4(transform.forward.x, transform.forward.y, transform.forward.z, 0));
if (m_Mirrored)
{
usedMaterial.SetVector("_Right", -new Vector4(transform.right.x, transform.right.y, transform.right.z, 0));
}
else
{
usedMaterial.SetVector("_Right", new Vector4(transform.right.x, transform.right.y, transform.right.z, 0));
}
usedMaterial.SetVector("_Up", new Vector4(transform.up.x, transform.up.y, transform.up.z, 0));
}
}
public static VCEComponentTool RayPickComponent(Ray ray, int order = 0)
{
if (!VCEditor.DocumentOpen())
{
return(null);
}
RaycastHit rch_v;
float voxel_dist = 1000000;
if (RayCastVoxel(ray, out rch_v, MC_ISO_VALUE))
{
voxel_dist = rch_v.distance * VCEditor.s_Scene.m_Setting.m_VoxelSize;;
}
RaycastHit[] rchs = Physics.RaycastAll(ray, VCEditor.s_Scene.m_Setting.EditorWorldSize.magnitude * 10F, VCConfig.s_EditorLayerMask);
RaycastHit temp_rch;
// Sort by dist
for (int i = 0; i < rchs.Length - 1; ++i)
{
for (int j = i + 1; j < rchs.Length; ++j)
{
if (rchs[i].distance > rchs[j].distance)
{
temp_rch = rchs[i];
rchs[i] = rchs[j];
rchs[j] = temp_rch;
}
}
}
List <VCEComponentTool> list_comp = new List <VCEComponentTool> ();
foreach (RaycastHit rch in rchs)
{
if (rch.distance <= voxel_dist)
{
GLComponentBound glcb = rch.collider.gameObject.GetComponent <GLComponentBound>();
if (glcb != null)
{
list_comp.Add(glcb.m_ParentComponent);
}
}
}
if (list_comp.Count == 0)
{
return(null);
}
else
{
return(list_comp[order % list_comp.Count]);
}
}
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 Start()
{
if (VCEditor.DocumentOpen())
{
m_SelectionMgr = VCEditor.Instance.m_VoxelSelection;
CreateMainInspector();
VCEditor.Instance.m_NearVoxelIndicator.enabled = true;
}
else
{
GameObject.Destroy(this.gameObject);
}
}
// Update is called once per frame
void Update()
{
if (!VCEditor.DocumentOpen())
{
return;
}
int MaxHeight = VCEditor.s_Scene.m_Setting.m_EditorSize.y;
m_Slider.numberOfSteps = MaxHeight + 1;
int yValue = Mathf.RoundToInt(m_Slider.sliderValue * MaxHeight);
m_Label.text = "Y = " + yValue.ToString();
VCERefPlane.YRef = yValue;
}
void Start()
{
if (VCEditor.DocumentOpen())
{
m_Selection = new List <SelectInfo> ();
CreateMainInspector();
}
else
{
GameObject.Destroy(this.gameObject);
}
// Gizmos events
m_MovingGizmo.OnDragBegin = OnGizmoBegin;
m_MovingGizmo.OnDrop = OnGizmoEnd;
m_MovingGizmo.OnMoving = OnMoving;
m_RotatingGizmo.OnDragBegin = OnGizmoBegin;
m_RotatingGizmo.OnDrop = OnGizmoEnd;
m_RotatingGizmo.OnRotating = OnRotating;
}
void OnGUI()
{
if (!VCEditor.DocumentOpen())
{
return;
}
GUI.skin = m_GUISkin;
if (m_alpha_pos_x > m_alpha_threshold && xShow)
{
GUI.Label(new Rect(xpoint.x - 10, Screen.height - xpoint.y - 15, 20, 20), "x", "AxisText");
}
if (m_alpha_pos_y > m_alpha_threshold && yShow)
{
GUI.Label(new Rect(ypoint.x - 10, Screen.height - ypoint.y - 15, 20, 20), "y", "AxisText");
}
if (m_alpha_pos_z > m_alpha_threshold && zShow)
{
GUI.Label(new Rect(zpoint.x - 10, Screen.height - zpoint.y - 15, 20, 20), "z", "AxisText");
}
}
// cast grid planes
public static bool RayCastGrid(Ray ray, out RaycastHit rch)
{
rch = new RaycastHit();
if (!VCEditor.DocumentOpen())
{
return(false);
}
if (Physics.Raycast(ray, out rch, VCEditor.s_Scene.m_Setting.EditorWorldSize.magnitude * 5F, VCConfig.s_EditorLayerMask))
{
if (rch.collider.gameObject.GetComponent <GLGridPlane>() != null)
{
rch.point = rch.point / VCEditor.s_Scene.m_Setting.m_VoxelSize;
rch.distance = rch.distance / VCEditor.s_Scene.m_Setting.m_VoxelSize;
return(true);
}
else
{
rch = new RaycastHit();
return(false);
}
}
return(false);
}
// Update is called once per frame
void Update()
{
if (VCEditor.DocumentOpen())
{
VCDecalAsset decal = VCEAssetMgr.GetDecal(m_GUID);
m_SelectedSign.SetActive(VCEditor.SelectedDecalGUID == m_GUID && m_GUID != 0);
int index = VCEditor.s_Scene.m_IsoData.QueryExistDecalIndex(decal);
if (index >= 0 && VCEditor.s_Scene.m_IsoData.m_DecalAssets[index] == decal)
{
m_IndexLabel.text = (index + 1).ToString() + " of " + VCIsoData.DECAL_ARR_CNT.ToString();
m_IndexLabel.color = Color.white;
}
else if (VCEditor.SelectedDecal == decal)
{
if (VCEditor.SelectedDecalIndex < 0)
{
m_IndexLabel.text = "FULL";
m_IndexLabel.color = Color.red;
}
else
{
m_IndexLabel.text = (VCEditor.SelectedDecalIndex + 1).ToString() + " of " + VCIsoData.DECAL_ARR_CNT.ToString();
m_IndexLabel.color = Color.white;
}
}
else
{
m_IndexLabel.text = "";
m_IndexLabel.color = Color.white;
}
bool tempdcl = VCEAssetMgr.s_TempDecals.ContainsKey(m_GUID);
bool existdcl = VCEAssetMgr.s_Decals.ContainsKey(m_GUID);
m_AddBtn.SetActive(tempdcl && !existdcl);
m_DelBtn.SetActive(!tempdcl && existdcl && index < 0 && VCEditor.SelectedDecal == decal);
}
}
// Update is called once per frame
void Update()
{
if (m_BrushPrefab == null)
{
return;
}
if (!VCEditor.DocumentOpen())
{
return;
}
UICheckbox cbox = GetComponent <UICheckbox>();
if (cbox != null)
{
if (cbox.isChecked)
{
if (m_BrushInstance == null)
{
m_BrushInstance = GameObject.Instantiate(m_BrushPrefab) as GameObject;
m_BrushInstance.transform.parent = VCEditor.Instance.m_BrushGroup.transform;
m_BrushInstance.transform.localPosition = Vector3.zero;
m_BrushInstance.transform.localRotation = Quaternion.identity;
m_BrushInstance.transform.localScale = Vector3.one;
m_BrushInstance.SetActive(true);
}
}
else
{
if (m_BrushInstance != null)
{
GameObject.Destroy(m_BrushInstance);
m_BrushInstance = null;
}
}
}
}
// Update is called once per frame
void LateUpdate()
{
if (!VCEditor.DocumentOpen())
{
return;
}
GetComponent <Camera>().pixelRect = m_RenderRect;
// Update view matrix
float AxisCamDist = 7.5f;
GetComponent <Camera>().transform.localPosition = Vector3.zero;
GetComponent <Camera>().transform.localRotation = m_MainCameraBehaviour.transform.localRotation;
GetComponent <Camera>().transform.localPosition -= GetComponent <Camera>().transform.forward *AxisCamDist;
// Set axis transparent
Vector3 sight = GetComponent <Camera>().transform.forward;
m_alpha_pos_x = AxisAlpha(Vector3.Angle(sight, -Vector3.right));
m_alpha_pos_y = AxisAlpha(Vector3.Angle(sight, -Vector3.up));
m_alpha_pos_z = AxisAlpha(Vector3.Angle(sight, -Vector3.forward));
m_alpha_neg_x = AxisAlpha(Vector3.Angle(sight, Vector3.right));
m_alpha_neg_y = AxisAlpha(Vector3.Angle(sight, Vector3.up));
m_alpha_neg_z = AxisAlpha(Vector3.Angle(sight, Vector3.forward));
m_alpha_origin = 1.0f;
m_XAxisMaterial.color = new Color(m_XAxisMaterial.color.r, m_XAxisMaterial.color.g, m_XAxisMaterial.color.b, m_alpha_pos_x);
m_YAxisMaterial.color = new Color(m_YAxisMaterial.color.r, m_YAxisMaterial.color.g, m_YAxisMaterial.color.b, m_alpha_pos_y);
m_ZAxisMaterial.color = new Color(m_ZAxisMaterial.color.r, m_ZAxisMaterial.color.g, m_ZAxisMaterial.color.b, m_alpha_pos_z);
m_NXAxisMaterial.color = new Color(m_NXAxisMaterial.color.r, m_NXAxisMaterial.color.g, m_NXAxisMaterial.color.b, m_alpha_neg_x);
m_NYAxisMaterial.color = new Color(m_NYAxisMaterial.color.r, m_NYAxisMaterial.color.g, m_NYAxisMaterial.color.b, m_alpha_neg_y);
m_NZAxisMaterial.color = new Color(m_NZAxisMaterial.color.r, m_NZAxisMaterial.color.g, m_NZAxisMaterial.color.b, m_alpha_neg_z);
m_OriginMaterial.color = new Color(m_OriginMaterial.color.r, m_OriginMaterial.color.g, m_OriginMaterial.color.b, m_alpha_origin);
// Pick axis
m_MouseRay = GetComponent <Camera>().ScreenPointToRay(Input.mousePosition);
Renderer focus = null;
float MinDist = 1000.0f;
float DestYaw = 0.0f;
float DestPitch = 0.0f;
m_mrXAxis.material = m_XAxisMaterial;
m_mrYAxis.material = m_YAxisMaterial;
m_mrZAxis.material = m_ZAxisMaterial;
m_mrNXAxis.material = m_NXAxisMaterial;
m_mrNYAxis.material = m_NYAxisMaterial;
m_mrNZAxis.material = m_NZAxisMaterial;
m_mrOrigin.material = m_OriginMaterial;
RaycastHit rchit;
if (m_alpha_pos_x > m_alpha_threshold && m_mrXAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrXAxis;
DestYaw = 0.0f;
DestPitch = 0.0f;
VCEStatusBar.ShowText("Right view".ToLocalizationString(), 2);
}
}
if (m_alpha_pos_y > m_alpha_threshold && m_mrYAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrYAxis;
DestYaw = 90.0f;
DestPitch = 90.0f;
VCEStatusBar.ShowText("Top view".ToLocalizationString(), 2);
}
}
if (m_alpha_pos_z > m_alpha_threshold && m_mrZAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrZAxis;
DestYaw = 90.0f;
DestPitch = 0.0f;
VCEStatusBar.ShowText("Front view".ToLocalizationString(), 2);
}
}
if (m_alpha_neg_x > m_alpha_threshold && m_mrNXAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrNXAxis;
DestYaw = 180.0f;
DestPitch = 0.0f;
VCEStatusBar.ShowText("Left view".ToLocalizationString(), 2);
}
}
if (m_alpha_neg_y > m_alpha_threshold && m_mrNYAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrNYAxis;
DestYaw = 90.0f;
DestPitch = -90.0f;
VCEStatusBar.ShowText("Bottom view".ToLocalizationString(), 2);
}
}
if (m_alpha_neg_z > m_alpha_threshold && m_mrNZAxis.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrNZAxis;
DestYaw = -90.0f;
DestPitch = 0.0f;
VCEStatusBar.ShowText("Back view".ToLocalizationString(), 2);
}
}
if (m_mrOrigin.GetComponent <Collider>().Raycast(m_MouseRay, out rchit, 100))
{
if (rchit.distance < MinDist)
{
MinDist = rchit.distance;
focus = m_mrOrigin;
DestYaw = m_MainCameraBehaviour.BeginYaw;
DestPitch = m_MainCameraBehaviour.BeginPitch;
VCEStatusBar.ShowText("Reset camera".ToLocalizationString(), 2);
}
}
// Click
if (MinDist < 999)
{
focus.material = m_FocusMaterial;
if (Input.GetMouseButtonDown(0))
{
while (DestYaw < m_MainCameraBehaviour.Yaw - 180.0f)
{
DestYaw += 360.0f;
}
while (DestYaw > m_MainCameraBehaviour.Yaw + 180.0f)
{
DestYaw -= 360.0f;
}
while (DestPitch < m_MainCameraBehaviour.Pitch - 180.0f)
{
DestPitch += 360.0f;
}
while (DestPitch > m_MainCameraBehaviour.Pitch + 180.0f)
{
DestPitch -= 360.0f;
}
m_MainCameraBehaviour.SetYaw(DestYaw);
m_MainCameraBehaviour.SetPitch(DestPitch);
}
}
// x,y,z Text calculate
xpoint = GetComponent <Camera>().WorldToScreenPoint(Vector3.right * m_TextOffset + transform.parent.position);
ypoint = GetComponent <Camera>().WorldToScreenPoint(Vector3.up * m_TextOffset + transform.parent.position);
zpoint = GetComponent <Camera>().WorldToScreenPoint(Vector3.forward * m_TextOffset + transform.parent.position);
Ray xRay = GetComponent <Camera>().ScreenPointToRay(xpoint);
Ray yRay = GetComponent <Camera>().ScreenPointToRay(ypoint);
Ray zRay = GetComponent <Camera>().ScreenPointToRay(zpoint);
xShow = true;
yShow = true;
zShow = true;
if (m_mrXAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrYAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrZAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrNXAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrNYAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrNZAxis.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrOrigin.GetComponent <Collider>().Raycast(xRay, out rchit, 100))
{
xShow = false;
}
if (m_mrXAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrYAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrZAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrNXAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrNYAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrNZAxis.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrOrigin.GetComponent <Collider>().Raycast(yRay, out rchit, 100))
{
yShow = false;
}
if (m_mrXAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrYAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrZAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrNXAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrNYAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrNZAxis.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = false;
}
if (m_mrOrigin.GetComponent <Collider>().Raycast(zRay, out rchit, 100))
{
zShow = 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);
}
}
public static bool RayCastDrawTarget(Ray ray, out DrawTarget target, int minvol, bool voxelbest = false)
{
target = new DrawTarget();
if (!VCEditor.DocumentOpen())
{
return(false);
}
// Cast grid and voxel above minvol
RaycastHit rch_voxel = new RaycastHit();
RaycastHit rch_grid = new RaycastHit();
float dist_voxel = 10000;
float dist_grid = 10000;
bool to_cast_grid = true;
if (VCEMath.RayCastVoxel(VCEInput.s_PickRay, out rch_voxel, minvol))
{
dist_voxel = rch_voxel.distance;
if (voxelbest)
{
to_cast_grid = false;
}
}
if (to_cast_grid && VCEMath.RayCastGrid(VCEInput.s_PickRay, out rch_grid))
{
if (rch_grid.normal.y > 0)
{
dist_grid = rch_grid.distance;
}
}
// cast voxel
if (dist_voxel < dist_grid)
{
target.rch = rch_voxel;
target.snapto = new IntVector3(Mathf.FloorToInt(rch_voxel.point.x - rch_voxel.normal.x * 0.5f),
Mathf.FloorToInt(rch_voxel.point.y - rch_voxel.normal.y * 0.5f),
Mathf.FloorToInt(rch_voxel.point.z - rch_voxel.normal.z * 0.5f));
target.cursor = new IntVector3(Mathf.FloorToInt(rch_voxel.point.x + rch_voxel.normal.x * 0.5f),
Mathf.FloorToInt(rch_voxel.point.y + rch_voxel.normal.y * 0.5f),
Mathf.FloorToInt(rch_voxel.point.z + rch_voxel.normal.z * 0.5f));
return(true);
}
// cast grid
else if (dist_grid < dist_voxel)
{
target.rch = rch_grid;
target.snapto = new IntVector3(Mathf.FloorToInt(rch_grid.point.x - rch_grid.normal.x * 0.5f),
Mathf.FloorToInt(rch_grid.point.y - rch_grid.normal.y * 0.5f),
Mathf.FloorToInt(rch_grid.point.z - rch_grid.normal.z * 0.5f));
target.cursor = new IntVector3(Mathf.FloorToInt(rch_grid.point.x + rch_grid.normal.x * 0.5f),
Mathf.FloorToInt(rch_grid.point.y + rch_grid.normal.y * 0.5f),
Mathf.FloorToInt(rch_grid.point.z + rch_grid.normal.z * 0.5f));
if (VCEditor.s_Scene.m_IsoData.GetVoxel(VCIsoData.IPosToKey(target.cursor)).Volume > VCEMath.MC_ISO_VALUE)
{
target.cursor = null;
return(false);
}
return(true);
}
// cast nothing
else
{
target.rch = new RaycastHit();
target.snapto = null;
target.cursor = null;
return(false);
}
}
public static bool RayCastCoordPlane(Ray ray, ECoordPlane coordplane, float position, out RaycastHit rch)
{
rch = new RaycastHit();
if (!VCEditor.DocumentOpen())
{
return(false);
}
float epsilon = 0.0001F;
ray = TransformRayToIsoCoord(ray);
ray.direction.Normalize();
if (coordplane == ECoordPlane.XY)
{
if (Mathf.Abs(ray.direction.z) < epsilon)
{
return(false);
}
float enter = (position - ray.origin.z) / ray.direction.z;
if (enter < 0.01f)
{
return(false);
}
rch.point = ray.GetPoint(enter);
rch.distance = enter;
rch.normal = ray.direction.z > 0 ? Vector3.back : Vector3.forward;
return(true);
}
else if (coordplane == ECoordPlane.XZ)
{
if (Mathf.Abs(ray.direction.y) < epsilon)
{
return(false);
}
float enter = (position - ray.origin.y) / ray.direction.y;
if (enter < 0.01f)
{
return(false);
}
rch.point = ray.GetPoint(enter);
rch.distance = enter;
rch.normal = ray.direction.y > 0 ? Vector3.down : Vector3.up;
return(true);
}
else if (coordplane == ECoordPlane.ZY)
{
if (Mathf.Abs(ray.direction.x) < epsilon)
{
return(false);
}
float enter = (position - ray.origin.x) / ray.direction.x;
if (enter < 0.01f)
{
return(false);
}
rch.point = ray.GetPoint(enter);
rch.distance = enter;
rch.normal = ray.direction.x > 0 ? Vector3.left : Vector3.right;
return(true);
}
else
{
return(false);
}
}
// pick a voxel
public static bool RayCastVoxel(Ray ray, out RaycastHit rch, int minvol = 1)
{
rch = new RaycastHit();
if (!VCEditor.DocumentOpen())
{
return(false);
}
VCIsoData iso = VCEditor.s_Scene.m_IsoData;
// Define a small number.
float epsilon = 0.0001F;
// Define a large number.
float upsilon = 10000F;
ray = TransformRayToIsoCoord(ray);
// ray origin inside a voxel
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(ray.origin.x),
Mathf.FloorToInt(ray.origin.y),
Mathf.FloorToInt(ray.origin.z))).Volume >= minvol)
{
return(false);
}
// Start and adder.
float xStart, yStart, zStart;
float xAdder, yAdder, zAdder;
if (ray.direction.x > epsilon)
{
xAdder = 1;
}
else if (ray.direction.x < -epsilon)
{
xAdder = -1;
}
else
{
xAdder = 0;
}
if (ray.direction.y > epsilon)
{
yAdder = 1;
}
else if (ray.direction.y < -epsilon)
{
yAdder = -1;
}
else
{
yAdder = 0;
}
if (ray.direction.z > epsilon)
{
zAdder = 1;
}
else if (ray.direction.z < -epsilon)
{
zAdder = -1;
}
else
{
zAdder = 0;
}
xStart = (int)(((int)ray.origin.x) + 1 + xAdder * 0.5f);
yStart = (int)(((int)ray.origin.y) + 1 + yAdder * 0.5f);
zStart = (int)(((int)ray.origin.z) + 1 + zAdder * 0.5f);
// Clamp the start
xStart = Mathf.Clamp(xStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.x);
yStart = Mathf.Clamp(yStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.y);
zStart = Mathf.Clamp(zStart, 0.0f, VCEditor.s_Scene.m_Setting.m_EditorSize.z);
// Normalize the ray
ray.direction = ray.direction.normalized;
// Define the Enter
float EnterX = upsilon + 1;
float EnterY = upsilon + 1;
float EnterZ = upsilon + 1;
// Find the X-cast Enter
if (xAdder != 0)
{
for (float x = xStart; x > -0.1f && x <= VCEditor.s_Scene.m_Setting.m_EditorSize.x + 0.1f; x += xAdder)
{
float enter = (x - ray.origin.x) / ray.direction.x;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x + xAdder * 0.5f),
Mathf.FloorToInt(Hit.y),
Mathf.FloorToInt(Hit.z))).Volume >= minvol)
{
EnterX = enter;
break;
}
}
}
// Find the Y-cast Enter
if (yAdder != 0)
{
for (float y = yStart; y >= -0.1f && y <= VCEditor.s_Scene.m_Setting.m_EditorSize.y + 0.1f; y += yAdder)
{
float enter = (y - ray.origin.y) / ray.direction.y;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x),
Mathf.FloorToInt(Hit.y + yAdder * 0.5f),
Mathf.FloorToInt(Hit.z))).Volume >= minvol)
{
EnterY = enter;
break;
}
}
}
// Find the Z-cast Enter
if (zAdder != 0)
{
for (float z = zStart; z >= -0.1f && z <= VCEditor.s_Scene.m_Setting.m_EditorSize.z + 0.1f; z += zAdder)
{
float enter = (z - ray.origin.z) / ray.direction.z;
Vector3 Hit = ray.origin + ray.direction * enter;
if (iso.GetVoxel(VCIsoData.IPosToKey(Mathf.FloorToInt(Hit.x),
Mathf.FloorToInt(Hit.y),
Mathf.FloorToInt(Hit.z + zAdder * 0.5f))).Volume >= minvol)
{
EnterZ = enter;
break;
}
}
}
// cull negative x,y,z cast result
if (EnterX < 0)
{
EnterX = upsilon + 1;
}
if (EnterY < 0)
{
EnterY = upsilon + 1;
}
if (EnterZ < 0)
{
EnterZ = upsilon + 1;
}
// no cast
if (EnterX > upsilon && EnterY > upsilon && EnterZ > upsilon)
{
return(false);
}
// x enter is the smallest
if (EnterX < EnterY && EnterX < EnterZ)
{
rch.point = ray.GetPoint(EnterX);
rch.normal = Vector3.left * xAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
// y enter is the smallest
else if (EnterY < EnterZ && EnterY < EnterX)
{
rch.point = ray.GetPoint(EnterY);
rch.normal = Vector3.down * yAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
// z enter is the smallest
else if (EnterZ < EnterX && EnterZ < EnterY)
{
rch.point = ray.GetPoint(EnterZ);
rch.normal = Vector3.back * zAdder;
rch.distance = (rch.point - ray.origin).magnitude;
return(true);
}
else
{
return(false);
}
}
private void CameraCtrl()
{
// Get some input axes.
float dx, dy, dw;
dx = Input.GetAxis("Mouse X");
dy = Input.GetAxis("Mouse Y");
dw = Input.GetAxis("Mouse ScrollWheel");
// Do orbit the camera.
if (Input.GetMouseButton(_OrbitKey) && CanOrbit)
{
if (ControlMode == 1)
{
if (Input.GetKey(_RollKey))
{
if (CanRoll)
{
_RollWanted = _RollWanted - dx * OrbitSensitive * 5.0f;
}
}
else
{
_YawWanted = _YawWanted - dx * OrbitSensitive * 5.0f;
_PitchWanted = _PitchWanted - dy * OrbitSensitive * 5.0f;
// 5.0 is a test coef
}
}
else if (ControlMode == 2)
{
if (Input.GetKey(_RollKey))
{
}
else
{
Vector3 right = Vector3.Cross(_Up, _Forward);
_ForwardWanted = _ForwardWanted + dx * OrbitSensitive * right * 0.1f;
_ForwardWanted = _ForwardWanted + dy * OrbitSensitive * _Up * 0.1f;
}
}
}
// Do move the camera.
else if (Input.GetMouseButton(_MoveKey) && CanMove)
{
Vector3 offset = (transform.right * _Dist * MoveSensitive * dx) +
(transform.up * _Dist * MoveSensitive * dy);
_TargetWanted = _TargetWanted - offset * 0.1f;
// 0.1 is a test coef
}
// Do zoom the camera.
if (dw != 0 && CanZoom)
{
_DistWanted = _DistWanted * Mathf.Pow(ZoomSensitive + 1.0f, -dw);
}
// Walk
if (!Input.GetKey(KeyCode.LeftShift) &&
!Input.GetKey(KeyCode.RightShift) &&
!Input.GetKey(KeyCode.LeftControl) &&
!Input.GetKey(KeyCode.RightControl) &&
!Input.GetKey(KeyCode.LeftAlt) &&
!Input.GetKey(KeyCode.RightAlt) &&
!UICamera.inputHasFocus)
{
if (Input.GetKey(KeyCode.W))
{
_TargetWanted = _TargetWanted + transform.forward * Time.deltaTime * _DistWanted;
}
if (Input.GetKey(KeyCode.S))
{
_TargetWanted = _TargetWanted - transform.forward * Time.deltaTime * _DistWanted;
}
if (Input.GetKey(KeyCode.A))
{
_TargetWanted = _TargetWanted - transform.right * Time.deltaTime * _DistWanted;
}
if (Input.GetKey(KeyCode.D))
{
_TargetWanted = _TargetWanted + transform.right * Time.deltaTime * _DistWanted;
}
if (Input.GetKey(KeyCode.Q))
{
_TargetWanted = _TargetWanted + transform.up * Time.deltaTime * _DistWanted;
}
if (Input.GetKey(KeyCode.Z))
{
_TargetWanted = _TargetWanted - transform.up * Time.deltaTime * _DistWanted;
}
}
if (VCEditor.DocumentOpen() && !Input.GetMouseButton(_MoveKey))
{
Bounds b = new Bounds(VCEditor.s_Scene.m_Setting.EditorWorldSize * 0.5f, VCEditor.s_Scene.m_Setting.EditorWorldSize * 3);
if (_TargetWanted.x < b.min.x)
{
_TargetWanted.x = b.min.x;
}
if (_TargetWanted.y < b.min.y)
{
_TargetWanted.y = b.min.y;
}
if (_TargetWanted.z < b.min.z)
{
_TargetWanted.z = b.min.z;
}
if (_TargetWanted.x > b.max.x)
{
_TargetWanted.x = b.max.x;
}
if (_TargetWanted.y > b.max.y)
{
_TargetWanted.y = b.max.y;
}
if (_TargetWanted.z > b.max.z)
{
_TargetWanted.z = b.max.z;
}
}
}
// Update is called once per frame
protected void Update()
{
if (!VCEditor.DocumentOpen() ||
VCEditor.SelectedVoxelType < 0)
{
m_Phase = EPhase.Free;
m_GizmoCube.gameObject.SetActive(false);
return;
}
float voxel_size = VCEditor.s_Scene.m_Setting.m_VoxelSize;
m_GizmoCube.m_VoxelSize = voxel_size;
ExtraAdjust();
if (m_Phase == EPhase.Free)
{
if (!VCEInput.s_MouseOnUI)
{
// Cancel
if (VCEInput.s_Cancel)
{
ResetDrawing();
Cancel();
}
VCEMath.RayCastDrawTarget(VCEInput.s_PickRay, out m_Target, VCEMath.MC_ISO_VALUE);
if (VCEditor.s_Scene.m_IsoData.IsPointIn(m_Target.cursor))
{
m_GizmoCube.CubeSize = IntVector3.One;
m_GizmoCube.transform.position = m_Target.cursor.ToVector3() * voxel_size;
m_GizmoCube.gameObject.SetActive(true);
if (Input.GetMouseButtonDown(0))
{
m_Begin = new IntVector3(m_Target.cursor);
m_End = new IntVector3(m_Target.cursor);
m_Phase = EPhase.DragPlane;
VCEditor.Instance.m_UI.DisableFunctions();
VCEditor.s_ProtectLock0 = true;
VCEStatusBar.ShowText("Drag an area".ToLocalizationString(), 2);
}
}
else
{
m_GizmoCube.gameObject.SetActive(false);
}
}
else
{
m_GizmoCube.gameObject.SetActive(false);
}
VCEditor.Instance.m_NearVoxelIndicator.enabled = true;
}
else if (m_Phase == EPhase.DragPlane)
{
// Cancel
if (VCEInput.s_Cancel)
{
ResetDrawing();
}
RaycastHit rch;
if (VCEMath.RayCastCoordPlane(VCEInput.s_PickRay, ECoordPlane.XZ, m_Begin.y, out rch))
{
m_End = new IntVector3(Mathf.FloorToInt(rch.point.x), m_Begin.y, Mathf.FloorToInt(rch.point.z));
VCEditor.s_Scene.m_IsoData.ClampPointI(m_End, m_Begin.x < 0.5f * VCEditor.s_Scene.m_IsoData.m_HeadInfo.xSize);
m_PointBeforeAdjustHeight = rch.point;
VCEditor.s_Scene.m_IsoData.ClampPointI(m_End, m_Begin.x < 0.5f * VCEditor.s_Scene.m_IsoData.m_HeadInfo.xSize);
m_GizmoCube.CubeSize = Size;
m_GizmoCube.transform.position = Min.ToVector3() * voxel_size;
}
else
{
ResetDrawing();
}
if (Input.GetMouseButtonUp(0))
{
m_Phase = EPhase.AdjustHeight;
VCEStatusBar.ShowText("Adjust height".ToLocalizationString(), 2);
}
VCEditor.Instance.m_NearVoxelIndicator.enabled = false;
}
else if (m_Phase == EPhase.AdjustHeight)
{
// Cancel
if (VCEInput.s_Cancel)
{
ResetDrawing();
}
float height = m_PointBeforeAdjustHeight.y;
VCEMath.RayAdjustHeight(VCEInput.s_PickRay, m_PointBeforeAdjustHeight, out height);
m_End.y = Mathf.FloorToInt(height + 0.3f);
VCEditor.s_Scene.m_IsoData.ClampPointI(m_End);
m_GizmoCube.CubeSize = Size;
m_GizmoCube.transform.position = Min.ToVector3() * voxel_size;
// Do the brush
if (Input.GetMouseButtonDown(0))
{
m_Phase = EPhase.Drawing;
Do();
VCEStatusBar.ShowText("Done".ToLocalizationString(), 2);
}
VCEditor.Instance.m_NearVoxelIndicator.enabled = false;
}
}
// Update is called once per frame
void Update()
{
if (!VCEditor.DocumentOpen() ||
VCEditor.SelectedVoxelType < 0 ||
VCEInput.s_MouseOnUI)
{
m_GizmoGroup.gameObject.SetActive(false);
return;
}
// Cancel
if (VCEInput.s_Cancel)
{
Cancel();
}
if (VCEInput.s_Shift && VCEInput.s_Left)
{
m_Offset = m_Offset - IntVector3.UnitX;
}
if (VCEInput.s_Shift && VCEInput.s_Right)
{
m_Offset = m_Offset + IntVector3.UnitX;
}
if (VCEInput.s_Shift && VCEInput.s_Up)
{
m_Offset = m_Offset + IntVector3.UnitY;
}
if (VCEInput.s_Shift && VCEInput.s_Down)
{
m_Offset = m_Offset - IntVector3.UnitY;
}
if (VCEInput.s_Shift && VCEInput.s_Forward)
{
m_Offset = m_Offset + IntVector3.UnitZ;
}
if (VCEInput.s_Shift && VCEInput.s_Back)
{
m_Offset = m_Offset - IntVector3.UnitZ;
}
float voxel_size = VCEditor.s_Scene.m_Setting.m_VoxelSize;
m_CursorGizmoCube.m_VoxelSize = voxel_size;
m_OffsetGizmoCube.m_VoxelSize = voxel_size;
if (VCEMath.RayCastDrawTarget(VCEInput.s_PickRay, out m_Target, VCEMath.MC_ISO_VALUE))
{
m_GizmoGroup.gameObject.SetActive(true);
IntVector3 draw = m_Target.cursor + m_Offset;
m_CursorGizmoCube.transform.position = m_Target.cursor.ToVector3() * voxel_size;
m_OffsetGizmoCube.transform.position = draw.ToVector3() * voxel_size;
bool cursor_in = VCEditor.s_Scene.m_IsoData.IsPointIn(m_Target.cursor);
bool offset_in = VCEditor.s_Scene.m_IsoData.IsPointIn(draw);
bool show_offset = (m_Offset.ToVector3().magnitude > 0.1f);
m_CursorGizmoCube.gameObject.SetActive(cursor_in && show_offset);
m_OffsetGizmoCube.gameObject.SetActive(offset_in);
if (cursor_in && offset_in && Input.GetMouseButtonDown(0))
{
Do();
}
}
else
{
m_GizmoGroup.gameObject.SetActive(false);
}
}
public void OnSceneCreate()
{
if (VCEditor.DocumentOpen())
{
VCESceneSetting setting = VCEditor.s_Scene.m_Setting;
// Tab
if (!m_ISOTab.isChecked)
{
m_PartTab.isChecked = true;
}
if (!VCEditor.s_Ready)
{
OnPartTab(false);
OnMaterialTab(false);
OnPaintTab(false);
OnDecalTab(false);
OnEffectTab(false);
OnISOTab(false);
m_PartTab.isChecked = true;
}
VCEditor.Instance.m_UI.m_IsoTip.Hide();
firstvalid = true;
UpdateErrorLabel();
// Title label
VCESceneSetting parentsetting = VCConfig.s_EditorScenes.Find(iter => iter.m_Id == setting.m_ParentId);
if (parentsetting.m_Id == 1)
{
m_TitleLabel.text = setting.m_Name.ToUpper().ToLocalizationString();
}
else
{
m_TitleLabel.text = parentsetting.m_Name.ToUpper().ToLocalizationString() + " - " + setting.m_Name.ToUpper().ToLocalizationString();
}
if (VCEditor.s_Scene.m_Setting.m_Category == EVCCategory.cgObject)
{
m_TitleLabel.text = "OBJECT".ToLocalizationString() + " - " + m_TitleLabel.text.ToLocalizationString();
}
m_SceneSizeLabel.text = " " +
setting.EditorWorldSize.x.ToString("0.##") + "m x " +
setting.EditorWorldSize.z.ToString("0.##") + "m x " +
setting.EditorWorldSize.y.ToString("0.##") + "m";
m_SceneSizeLabel2.text =
VCUtils.LengthToString(setting.m_MajorInterval * setting.m_VoxelSize) + "\r\n" +
VCUtils.LengthToString(setting.m_MinorInterval * setting.m_VoxelSize) + "\r\n" +
VCUtils.LengthToString(setting.m_VoxelSize);
// Part List
m_PartList.InitTypeList();
m_PartList.RefreshPartList(m_PartTypePopupList.selection);
m_PartList.RepositionList();
// Material List
m_MaterialList.InitMatterList();
m_MaterialList.RefreshMaterialList(m_MatterPopupList.selection);
m_MaterialList.RepositionList();
// Decal List
m_DecalList.RefreshDecalList();
m_DecalList.RepositionList();
// Iso List
m_IsoList.RefreshIsoList();
m_IsoList.RepositionList();
// Stat
m_StatPanel.SetIsoIcon();
m_StatPanel.OnCreationInfoRefresh();
}
}
// Update is called once per frame
void Update()
{
if (!VCEditor.DocumentOpen())
{
return;
}
if (VCEditor.Instance.m_UI.m_MaterialTab.isChecked)
{
if (VCEditor.SelectedMaterial != null)
{
if (m_lastMat != VCEditor.SelectedMaterial)
{
m_UIGroup.SetActive(true);
m_MaterialIconTexture.mainTexture = VCEditor.SelectedMaterial.m_DiffuseTex;
m_MaterialIcon.material = m_MaterialIconTexture;
m_IconMask.GetComponent <UITweener>().Reset();
m_IconMask.GetComponent <UITweener>().Play(true);
m_GlowIcon.Reset();
m_GlowIcon.Play(true);
m_MaterialIcon.gameObject.SetActive(true);
m_ComponentIcon.gameObject.SetActive(false);
m_ColorIcon.gameObject.SetActive(false);
m_ItemNameLabel.text = VCEditor.SelectedMaterial.m_Name;
m_IconMask.SetActive(true);
}
}
else
{
m_UIGroup.SetActive(false);
}
m_lastMat = VCEditor.SelectedMaterial;
m_lastDecal = null;
m_lastPart = null;
m_lastColor = Color.clear;
}
else if (VCEditor.Instance.m_UI.m_DecalTab.isChecked)
{
if (VCEditor.SelectedDecal != null)
{
if (m_lastDecal != VCEditor.SelectedDecal)
{
m_UIGroup.SetActive(true);
m_MaterialIconTexture.mainTexture = VCEditor.SelectedDecal.m_Tex;
m_MaterialIcon.material = m_MaterialIconTexture;
m_IconMask.GetComponent <UITweener>().Reset();
m_IconMask.GetComponent <UITweener>().Play(true);
m_GlowIcon.Reset();
m_GlowIcon.Play(true);
m_MaterialIcon.gameObject.SetActive(true);
m_ComponentIcon.gameObject.SetActive(false);
m_ColorIcon.gameObject.SetActive(false);
m_ItemNameLabel.text = "1 " + "decal".ToLocalizationString() + " [999999](UID = " + VCEditor.SelectedDecal.GUIDString + ")[-]";
m_IconMask.SetActive(true);
}
}
else
{
m_UIGroup.SetActive(false);
}
m_lastDecal = VCEditor.SelectedDecal;
m_lastMat = null;
m_lastPart = null;
m_lastColor = Color.clear;
}
else if (VCEditor.Instance.m_UI.m_PartTab.isChecked)
{
if (VCEditor.SelectedPart != null)
{
if (m_lastPart != VCEditor.SelectedPart)
{
m_ComponentIcon.spriteName = VCEditor.SelectedPart.m_IconPath.Split(',')[0];
m_IconMask.GetComponent <UITweener>().Reset();
m_IconMask.GetComponent <UITweener>().Play(true);
m_GlowIcon.Reset();
m_GlowIcon.Play(true);
m_ComponentIcon.gameObject.SetActive(true);
m_UIGroup.SetActive(true);
m_MaterialIcon.gameObject.SetActive(false);
m_ColorIcon.gameObject.SetActive(false);
m_ItemNameLabel.text = VCEditor.SelectedPart.m_Name;
m_IconMask.SetActive(true);
}
}
else
{
m_UIGroup.SetActive(false);
}
m_lastMat = null;
m_lastDecal = null;
m_lastPart = VCEditor.SelectedPart;
m_lastColor = Color.clear;
}
else if (VCEditor.Instance.m_UI.m_PaintTab.isChecked)
{
Color color = VCEditor.SelectedColor;
color.a = 1;
m_ColorIcon.color = color;
if (m_lastColor != color)
{
m_IconMask.GetComponent <UITweener>().Reset();
m_IconMask.GetComponent <UITweener>().Play(true);
m_GlowIcon.Reset();
m_GlowIcon.Play(true);
}
m_ColorIcon.gameObject.SetActive(true);
m_UIGroup.SetActive(true);
m_MaterialIcon.gameObject.SetActive(false);
m_ComponentIcon.gameObject.SetActive(false);
m_ItemNameLabel.text = "RGB ( " + (color.r * 100).ToString("0") + "%, " + (color.g * 100).ToString("0") + "%, " + (color.b * 100).ToString("0") + "% )";
m_IconMask.SetActive(true);
m_lastMat = null;
m_lastDecal = null;
m_lastPart = null;
m_lastColor = color;
}
else
{
m_UIGroup.SetActive(false);
m_lastMat = null;
m_lastDecal = null;
m_lastPart = null;
m_lastColor = Color.clear;
}
}
// Generate a mesh material for VOXEL CREATIONs
public ulong GenMeshMaterial(VCMaterial[] mat_list, bool bForEditor = false)
{
// Prepare textures
RenderTexture diff_rtex = null;
RenderTexture bump_rtex = null;
Texture2D prop_tex = null;
Vector4 Setting1 = new Vector4(1.0F / ((float)VCIsoData.MAT_COL_CNT),
1.0F / ((float)VCIsoData.MAT_ROW_CNT),
1.0F,
VCMaterial.TEX_RESOLUTION);
// Get mat_list's hash code
ulong _guid = VCMaterial.CalcMatGroupHash(mat_list);
// For editor, VCEditor.s_Scene
if (bForEditor)
{
if (!VCEditor.DocumentOpen())
{
return(0);
}
diff_rtex = VCEditor.s_Scene.m_TempIsoMat.m_DiffTex;
bump_rtex = VCEditor.s_Scene.m_TempIsoMat.m_BumpTex;
prop_tex = VCEditor.s_Scene.m_TempIsoMat.m_PropertyTex;
Material final_mat = VCEditor.s_Scene.m_TempIsoMat.m_EditorMat;
final_mat.SetTexture("_DiffuseTex", diff_rtex);
final_mat.SetTexture("_BumpTex", bump_rtex);
final_mat.SetTexture("_PropertyTex", prop_tex);
final_mat.SetVector("_Settings1", Setting1);
}
// Not for editor, VCMatManagr
else
{
if (VCMatManager.Instance == null)
{
return(0);
}
// Has material group in VCMatManager (hash exist)
if (VCMatManager.Instance.m_mapMaterials.ContainsKey(_guid))
{
// Fetch textures
diff_rtex = VCMatManager.Instance.m_mapDiffuseTexs[_guid];
bump_rtex = VCMatManager.Instance.m_mapBumpTexs[_guid];
prop_tex = VCMatManager.Instance.m_mapPropertyTexs[_guid];
}
// A new material group (hash not exist)
else
{
// Create new textures
diff_rtex = new RenderTexture(VCIsoData.MAT_COL_CNT * VCMaterial.TEX_RESOLUTION,
VCIsoData.MAT_ROW_CNT * VCMaterial.TEX_RESOLUTION,
0, RenderTextureFormat.ARGB32);
bump_rtex = new RenderTexture(VCIsoData.MAT_COL_CNT * VCMaterial.TEX_RESOLUTION,
VCIsoData.MAT_ROW_CNT * VCMaterial.TEX_RESOLUTION,
0, RenderTextureFormat.ARGB32);
prop_tex = new Texture2D(VCIsoData.MAT_ARR_CNT, 4, TextureFormat.ARGB32, false, false);
diff_rtex.anisoLevel = 4;
diff_rtex.filterMode = FilterMode.Trilinear;
diff_rtex.useMipMap = true;
diff_rtex.wrapMode = TextureWrapMode.Repeat;
bump_rtex.anisoLevel = 4;
bump_rtex.filterMode = FilterMode.Trilinear;
bump_rtex.useMipMap = true;
bump_rtex.wrapMode = TextureWrapMode.Repeat;
prop_tex.anisoLevel = 0;
prop_tex.filterMode = FilterMode.Point;
// Set u3d material params
Material final_mat = Material.Instantiate(m_TemplateMeshMat) as Material;
final_mat.name = "VCMat #" + _guid.ToString("X").PadLeft(16, '0');
final_mat.SetTexture("_DiffuseTex", diff_rtex);
final_mat.SetTexture("_BumpTex", bump_rtex);
final_mat.SetTexture("_PropertyTex", prop_tex);
final_mat.SetVector("_Settings1", Setting1);
// Add to VCMatManager
VCMatManager.Instance.m_mapMaterials.Add(_guid, final_mat);
VCMatManager.Instance.m_mapDiffuseTexs.Add(_guid, diff_rtex);
VCMatManager.Instance.m_mapBumpTexs.Add(_guid, bump_rtex);
VCMatManager.Instance.m_mapPropertyTexs.Add(_guid, prop_tex);
VCMatManager.Instance.m_mapMatRefCounters.Add(_guid, 0);
}
}
//
// Render Material's Texture
//
m_TexturePlanesGroup.gameObject.SetActive(true);
// Gen diffuse
for (int i = 0; i < mat_list.Length && i < VCIsoData.MAT_ARR_CNT; ++i)
{
// Set diffuses on each piece of plane.
if (mat_list[i] != null)
{
m_PlaneRenderers[i].material.SetTexture("_MainTex", mat_list[i].m_DiffuseTex);
}
else
{
m_PlaneRenderers[i].material.SetTexture("_MainTex", Resources.Load(VCMaterial.s_BlankDiffuseRes) as Texture2D);
}
}
m_TextureCam.targetTexture = diff_rtex;
m_TextureCam.Render(); // render diffuse
// Gen bump
for (int i = 0; i < mat_list.Length && i < VCIsoData.MAT_ARR_CNT; ++i)
{
// Set normal maps on each piece of plane.
if (mat_list[i] != null)
{
m_PlaneRenderers[i].material.SetTexture("_MainTex", mat_list[i].m_BumpTex);
}
else
{
m_PlaneRenderers[i].material.SetTexture("_MainTex", Resources.Load(VCMaterial.s_BlankBumpRes) as Texture2D);
}
}
m_TextureCam.targetTexture = bump_rtex;
m_TextureCam.Render(); // render bump
// Gen properties
for (int i = 0; i < mat_list.Length && i < VCIsoData.MAT_ARR_CNT; ++i)
{
// Property texture has several property track in y direction
// each track have n pixels (n = VCIsoData.MAT_ARR_CNT) in x direction,
// each pixel represents the property or the combination of several properties for one material.
if (mat_list[i] != null)
{
prop_tex.SetPixel(i, 0, mat_list[i].m_SpecularColor);
prop_tex.SetPixel(i, 1, mat_list[i].m_EmissiveColor);
prop_tex.SetPixel(i, 2, new Color(mat_list[i].m_BumpStrength, mat_list[i].m_SpecularStrength / 2, mat_list[i].m_SpecularPower / 255, 1));
prop_tex.SetPixel(i, 3, new Color(mat_list[i].m_Tile / 17, 0, 0, 1));
}
else
{
prop_tex.SetPixel(i, 0, Color.black);
prop_tex.SetPixel(i, 1, Color.black);
prop_tex.SetPixel(i, 2, new Color(0, 0, 5 / 255, 1));
prop_tex.SetPixel(i, 3, new Color(1 / 17, 0, 0, 1));
}
}
prop_tex.Apply();
m_TextureCam.targetTexture = null;
m_TexturePlanesGroup.gameObject.SetActive(false);
return(_guid);
}