private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
LightTilemapCollider.Base tilemap = GetCurrentTilemap();
foreach (LightTile tile in GetTileList())
{
GizmosHelper.DrawPolygons(tile.GetWorldPolygons(tilemap), transform.position);
}
// GizmosHelper.DrawPolygons(superTilemapEditor.GetWorldColliders(), transform.position);
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, GetCurrentTilemap().GetRect());
break;
}
}
private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
LightTilemapCollider.Base tilemap = GetCurrentTilemap();
foreach (DayLightingTile dayTile in dayTiles)
{
GizmosHelper.DrawPolygons(dayTile.polygons, transform.position);
}
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, tilemap.GetRect());
break;
}
}
private void OnDrawGizmosSelected()
{
GUIStyle uIStyle = new GUIStyle();
uIStyle.fontSize = 30;
uIStyle.fontStyle = FontStyle.Bold;
ED_ActorPathPointCom[] pointComs = gameObject.GetComponentsInChildren <ED_ActorPathPointCom>(true);
if (pointComs != null)
{
for (int i = 0; i < pointComs.Length; i++)
{
ED_ActorPathPointCom tPointCom = pointComs[i];
int nextIndex = i + 1;
if (nextIndex > 0 && nextIndex < pointComs.Length)
{
ED_ActorPathPointCom tNextPointCom = pointComs[nextIndex];
GizmosHelper.DrawLine(tPointCom.transform.position, tNextPointCom.transform.position, Color.white);
}
GUI.color = Color.black;
Handles.Label(tPointCom.transform.position, (i + 1).ToString(), uIStyle);
GUI.color = Color.white;
}
}
}
private void DrawConnectionsFromTransforms()
{
if (PointsTransforms == null)
{
return;
}
if (PointsTransforms.Length <= 2)
{
return;
}
Transform last = PointsTransforms[PointsTransforms.Length - 1];
for (int i = 0; i < PointsTransforms.Length; i++)
{
if (last != null && PointsTransforms[i] != null)
{
Gizmos.color = Color.magenta;
Gizmos.DrawLine(last.position, PointsTransforms[i].position);
// draw id
Vector3 midPosition = last.position;
midPosition += (PointsTransforms[i].position - last.position) / 2f;
Gizmos.color = Color.white;
GizmosHelper.DrawString(midPosition, new Vector3(GizmoScale, GizmoScale), i.ToString());
}
last = PointsTransforms[i];
}
}
private void DrawGizmos() {
if (isActiveAndEnabled == false) {
return;
}
Gizmos.color = new Color(0, 1f, 1f);
if (Lighting2D.ProjectSettings.editorView.drawGizmosBounds == EditorGizmosBounds.Rectangle) {
for(int i = 0; i < cameraSettings.Length; i++) {
CameraSettings cameraSetting = cameraSettings[i];
Camera camera = cameraSetting.GetCamera();
if (camera != null) {
Rect cameraRect = CameraTransform.GetWorldRect(camera);
GizmosHelper.DrawRect(transform.position, cameraRect);
}
}
}
for(int i = 0; i < Scriptable.LightSprite2D.List.Count; i++) {
Scriptable.LightSprite2D light = Scriptable.LightSprite2D.List[i];
Rect rect = light.lightSpriteShape.GetWorldRect();
Gizmos.color = new Color(1f, 0.5f, 0.25f);
GizmosHelper.DrawPolygon(light.lightSpriteShape.GetSpriteWorldPolygon(), transform.position);
Gizmos.color = new Color(0, 1f, 1f);
GizmosHelper.DrawRect(transform.position, rect);
}
}
private void SetWaypoint(int index)
{
_currentWaypointIndex = index;
_movementBehaviour.SetDestination(_player.position + _relativeWaypoints[_currentWaypointIndex], AiSettings.WALK_SPEED);
_currentWaypointSetDistance = Vector3.Distance(_owner.position, _player.position + _relativeWaypoints[_currentWaypointIndex]);
GizmosHelper.DrawSphere(_player.position + _relativeWaypoints[_currentWaypointIndex], 1f, Color.green, 5f);
}
/// <summary>
/// If this Camera Track is a single position (rather than a shape), draw a reticle gizmo at that position.
/// </summary>
public void DrawGizmo()
{
if (_colliders == null || _colliders.Length == 0)
{
Gizmos.color = GizmosHelper.ColliderColor;
GizmosHelper.DrawCrosshairs2D(transform.position, 1f);
GizmosHelper.DrawShapeDiamond2D(transform.position, 0.5f);
}
}
public void DrawRay()
{
Vector3 pos = CameraManager.GetInstance().GetMainCamereComponent().GetPosition();
for (int i = 0; i < reyList.Count; i++)
{
Vector3 hitpos = pos + reyList[i] * 10;
GizmosHelper.GetInstance().DrawLine(pos, hitpos, Color.gray);
}
}
void OnDrawGizmos()
{
if (_collider == null)
{
_collider = GetComponent <BoxCollider2D>();
}
var bounds = _collider.bounds;
GizmosHelper.GizmosDrawRect(new Rect(bounds.min, bounds.size));
}
void Update()
{
if (CurrentBeatCombination != null)
{
float timeSinceLastBeat = Time.time - CurrentBeatCombination.m_timeAtLastBeat;
//Debug.Log(timeSinceLastBeat + " " + (timeSinceLastBeat < CurrentBeatCombination.m_inputAcceptanceDuration / 2f) + " " + (timeSinceLastBeat > CurrentBeatCombination.m_beatDuration - (CurrentBeatCombination.m_inputAcceptanceDuration / 2f)));
if (timeSinceLastBeat < CurrentBeatCombination.m_inputAcceptanceDuration / 2f ||
timeSinceLastBeat > CurrentBeatCombination.m_beatDuration - (CurrentBeatCombination.m_inputAcceptanceDuration / 2f))
{
GizmosHelper.AddText(new Vector3(-4, -2.5f, 0), CurrentBeatCombination.m_beats[CurrentBeatCombination.m_currentBeatIndex].m_first.ToString(), Color.red, Time.deltaTime * 2);
}
}
}
void OnDrawGizmos()
{
if (cam == null)
{
return;
}
Quaternion shift = Quaternion.Euler(new Vector3(eularXOffset, 0, 0));
Vector3 fwd = shift * transform.forward;
Vector3 up = shift * transform.up;
Gizmos.color = Color.green;
GizmosHelper.DrawFrustum(transform.position, fwd, up, fov, aspect, cam.nearClipPlane, cam.farClipPlane);
}
private void UpdateBeat()
{
if (Get <GameController>().hasFinished)
{
return;
}
if (m_currentBeat == m_musicData.FinishBeat)
{
string musicKey;
if (m_musicData.BeatUpdate.TryGetValue(m_currentBeat, out musicKey))
{
AkSoundEngine.SetState("STATES_MainMusic", musicKey);
m_acceptBeat = !musicKey.Contains("Transition");
}
Get <GameController>().Win();
return;
}
if (m_prevBeatTime < 0)
{
m_prevBeatTime = Time.time;
return;
}
BeatDuration = Time.time - m_prevBeatTime;
m_prevBeatTime = Time.time;
if (1 / BeatDuration > 3f)
{
BeatDuration = 2.02877f;
}
Speed = 1 / BeatDuration;
Token.Speed = Speed;
BackgroundManager.Speed = Speed;
Get <ActionButton>().CharacterAnimator.speed = Speed / 2;
Debug.Log(Token.Speed);
OnMusicBeat?.Invoke();
m_audioSource.Play();
GizmosHelper.AddBox(Vector3.zero, Vector3.one * 54, Color.blue, BeatDuration / 2f);
m_currentBeat++;
BeatCombination bc;
if (m_musicData.BeatDict.TryGetValue(m_currentBeat, out bc))
{
OnActivateCombination?.Invoke(bc, BeatDuration);
GizmosHelper.AddBox(Vector3.zero, Vector3.one * 5, Color.red, BeatDuration / 2f);
}
}
private void CreateWaypoints()
{
_relativeWaypoints = new List <Vector3>();
for (int i = 0; i < 4; i++)
{
Vector2 randomPoint = UnityEngine.Random.insideUnitCircle.normalized * 15f;
_relativeWaypoints.Add(new Vector3(randomPoint.x, 0f, randomPoint.y));
}
for (int i = 0; i < _relativeWaypoints.Count; i++)
{
GizmosHelper.DrawSphere(_player.position + _relativeWaypoints[i], 1f, Color.red, 4f);
}
}
private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
if (mainShape.shadowType != LightCollider2D.ShadowType.None)
{
foreach (LightColliderShape shape in shapes)
{
List <Polygon2> polygons = shape.GetPolygonsWorld();
GizmosHelper.DrawPolygons(polygons, transform.position);
}
}
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
if (maskEffect == MaskEffect.Isometric)
{
Gizmos.color = Color.green;
GizmosHelper.DrawIsoRect(transform.position, mainShape.GetIsoWorldRect());
}
else
{
Gizmos.color = new Color(0, 1f, 1f);
GizmosHelper.DrawRect(transform.position, mainShape.GetWorldRect());
}
break;
}
Vector2?pivotPoint = mainShape.GetPivotPoint();
if (pivotPoint != null)
{
Vector3 pos = transform.position;
pos.x = pivotPoint.Value.x;
pos.y = pivotPoint.Value.y;
Gizmos.DrawIcon(pos, "circle_v2", true);
}
}
public virtual void OnDrawGizmos()
{
//get children
if (PointInput == FSShapePointInput.Transform)
{
List <Transform> tps = new List <Transform>(TransformPoints);
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
if (tps.Contains(child))
{
Gizmos.color = Color.magenta;
Gizmos.DrawSphere(child.position, 0.13f);
}
else
{
Gizmos.color = Color.white;
Gizmos.DrawWireSphere(child.position, 0.1f);
}
}
// draw connections
Transform last = null;
if (TransformPoints != null)
{
if (TransformPoints.Length > 2)
{
last = TransformPoints[TransformPoints.Length - 1];
for (int i = 0; i < TransformPoints.Length; i++)
{
if (last != null && TransformPoints[i] != null)
{
Gizmos.color = Color.magenta;
Gizmos.DrawLine(last.position, TransformPoints[i].position);
// draw id
Vector3 txtp = last.position;
txtp += (TransformPoints[i].position - last.position) / 2f;
Gizmos.color = Color.white;
GizmosHelper.DrawString(txtp, i.ToString());
}
last = TransformPoints[i];
}
}
}
}
else
{
}
}
#pragma warning disable 0649
#pragma warning restore 0649
#endregion // Serialized Types
#endregion // Types
#region Fields
#region Serialized Fields
#pragma warning disable 0649
#pragma warning restore 0649
#endregion // Serialized Fields
#endregion // Fields
#region Properties
#endregion // Properties
#region Mono
#endregion // Mono
#region Methods
protected void OnDrawGizmos()
{
var collider = GetComponent <BoxCollider2D>();
if (collider == null)
{
return;
}
GizmosHelper.Scope(() =>
{
Gizmos.matrix = transform.localToWorldMatrix;
Gizmos.DrawWireCube(collider.offset, collider.size);
});
}
private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
// Gizmos.color = new Color(1f, 0.5f, 0.25f);
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, GetCurrentTilemap().GetRect());
break;
}
}
void OnDrawGizmos()
{
var spawn = transform.Find("h_free");
if (spawn)
{
Gizmos.DrawIcon(spawn.position + Vector3.up * 0.5f, "h_free");
GizmosHelper.DrawAxis(spawn);
}
if (HPoint_Container)
{
foreach (var hpd in HPoint_Container.GetComponentsInChildren <HPointData>())
{
GizmosHelper.HPoint(hpd);
}
}
}
private void OnDrawGizmosSelected()
{
if (rampEndMarker != null)
{
// Draw a vertical dashed line to denote the ramp end location.
Gizmos.color = Color.white;
GizmosHelper.DrawAsymptote(rampEndMarker.position.x);
Handles.Label(rampEndMarker.position + Vector3.right * 0.5f, "Ramp End");
}
Gizmos.color = Color.red;
if (hitCircles != null)
{
foreach (CircleRegion circle in hitCircles)
{
GizmosHelper.DrawCircle((Vector2)transform.position + circle.position, circle.radius);
}
}
}
/// <summary>
/// 改善的，获取目标列表
/// </summary>
/// <returns></returns>
protected override List <Target> ImproveGetTarget()
{
List <Target> targets = base.ImproveGetTarget();
Vector3 pos = CameraManager.GetInstance().GetMainCamereComponent().GetPosition();
Vector3 direction = IsChangCheckDirection ? m_CheckDirection : CameraManager.GetInstance().GetMainCamereComponent().GetForward();
Collider[] colliders = Physics.OverlapSphere(pos, m_crosssightinfo.m_MaxRayDistance, LayerUtil.GetLayersIntersectWithSkillProjectile(true) /*LayerMask.GetMask("Enemy")*/);
Plane[] planes = null;
// 更新虚拟相机的方向和位置
if (m_virtualCamera != null)
{
m_virtualCamera.transform.position = pos;
m_virtualCamera.transform.rotation = CameraManager.GetInstance().GetMainCamereComponent().GetRotation();
planes = GeometryUtility.CalculateFrustumPlanes(m_virtualCamera);
}
for (int i = 0; i < colliders.Length; i++)
{
if (planes == null)
{
break;
}
if (GeometryUtility.TestPlanesAABB(planes, colliders[i].bounds))
{
BaseEntity entity = colliders[i].attachedRigidbody?.GetComponent <BaseEntity>();
if (entity != null && CCrossSightLoic.IsAdd(targets, entity.EntityId()))
{
Target target = new Target();
target.target_entityId = entity.EntityId();
target.target_pos = entity.transform.position;
targets.Add(target);
GizmosHelper.GetInstance().DrawLine(pos, target.target_pos, Color.red);
}
}
}
return(targets);
}
private void DrawGizmos()
{
Gizmos.color = new Color(1f, 0.5f, 0.25f);
if (mainShape.shadowType != DayLightCollider2D.ShadowType.None)
{
foreach (DayLightColliderShape shape in shapes)
{
shape.ResetWorld();
List <Polygon2> polygons = shape.GetPolygonsWorld();
if (polygons != null)
{
GizmosHelper.DrawPolygons(polygons, transform.position);
}
}
if (mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteProjection)
{
Vector2 pos = transform.position;
float rot = Lighting2D.DayLightingSettings.direction * Mathf.Deg2Rad;
Pair2 pair = Pair2.Zero();
pair.A = pos + pair.A.Push(-rot + Mathf.PI / 2, shadowThickness);
pair.B = pos + pair.B.Push(-rot - Mathf.PI / 2, shadowThickness);
Gizmos.DrawLine(pair.A, pair.B);
}
}
/*
* switch(Lighting2D.ProjectSettings.editorView.drawGizmosBounds) {
* case LightingSettings.EditorView.GizmosBounds.Rectangle:
* GizmosHelper.DrawRect(transform.position, mainShape.GetWorldRect());
* break;
*
* case LightingSettings.EditorView.GizmosBounds.Radius:
* GizmosHelper.DrawCircle(transform.position, 0, 360, mainShape.GetRadiusWorld());
* break;
* }*/
}
public void EditorDraw()
{
Arrow t1 = new Arrow(), t2 = new Arrow();
t1.start = rightTangent.tangentStart;
t1.direction = rightTangent.tangentEnd - rightTangent.tangentStart;
t2.start = leftTangent.tangentStart;
t2.direction = leftTangent.tangentEnd - leftTangent.tangentStart;
GizmosHelper.DrawGizmosShape(t1);
GizmosHelper.DrawGizmosShape(t2);
BrokenLine curve = new BrokenLine();
curve.points = new List <Vector3>(points);
curve.shapeColor = Color.green;
GizmosHelper.DrawGizmosShape(curve);
}
void Draw()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
GizmosHelper.DrawPolygon(lightSpriteShape.GetSpriteWorldPolygon(), transform.position);
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, lightSpriteShape.GetWorldRect());
break;
}
}
private void DrawBoxOnGUI()
{
MainCameraComponent mainCam = CameraManager.GetInstance().GetMainCamereComponent();
if (mainCam == null)
{
return;
}
for (int iAim = 0; iAim < m_SubAimAreas.Count; iAim++)
{
AimArea aimArea = m_SubAimAreas[iAim];
m_SubAimAreas[iAim].UpdateBaseRay(GetViewRay().direction);
Vector3 aimDir = m_SubAimAreas[iAim].GetBaseRay();
Vector3 pos = mainCam.GetPosition() + aimDir;
Vector3 screenPos = mainCam.GetCamera().WorldToScreenPoint(pos);
GizmosHelper.GetInstance().DrawGUIBox(screenPos, 100);
}
}
private void DrawGizmo()
{
MainCameraComponent mainCam = CameraManager.GetInstance().GetMainCamereComponent();
if (mainCam == null)
{
return;
}
// 根据当前瞄准方向更新主区域的目标信息
m_MainAimArea.UpdateBaseRay(GetViewRay().direction);
Vector3 baseRayPos = mainCam.GetPosition() + m_MainAimArea.GetBaseRay();
GizmosHelper.GetInstance().DrawCircle(baseRayPos, 0.05f);
m_MainAimArea.UpdateRayList(false);
m_MainAimArea.GetRayList(ref m_AimDirectionsCache);
for (int iRay = 0; iRay < m_AimDirectionsCache.Count; iRay++)
{
Vector3 pos = mainCam.GetPosition() + m_AimDirectionsCache[iRay];
GizmosHelper.GetInstance().DrawCircle(pos, 0.005f);
GizmosHelper.GetInstance().DrawLine(mainCam.GetPosition(), mainCam.GetPosition() + m_AimDirectionsCache[iRay] * 5);
}
// 根据当前瞄准方向更新主区域的目标信息
for (int iAim = 0; iAim < m_SubAimAreas.Count; iAim++)
{
m_SubAimAreas[iAim].UpdateBaseRay(GetViewRay().direction);
baseRayPos = mainCam.GetPosition() + m_SubAimAreas[iAim].GetBaseRay();
GizmosHelper.GetInstance().DrawCircle(baseRayPos, 0.05f);
m_SubAimAreas[iAim].UpdateRayList(false);
m_SubAimAreas[iAim].GetRayList(ref m_AimDirectionsCache);
for (int iRay = 0; iRay < m_AimDirectionsCache.Count; iRay++)
{
Vector3 pos = mainCam.GetPosition() + m_AimDirectionsCache[iRay];
GizmosHelper.GetInstance().DrawCircle(pos, 0.005f);
GizmosHelper.GetInstance().DrawLine(mainCam.GetPosition(), mainCam.GetPosition() + m_AimDirectionsCache[iRay] * 5);
}
}
}
private void OnDrawGizmos()
{
if (!Application.isPlaying)
{
if (NavigationGraphAsset != null && NavigationGraphAsset.NavigationLinks != null)
{
Matrix4x4 l_localToWorldMatrix = transform.localToWorldMatrix;
foreach (var l_navigationNodeEntry in NavigationGraphAsset.NavigationNodes)
{
Vector3 l_nodePosition = l_localToWorldMatrix.MultiplyPoint(l_navigationNodeEntry.Value.LocalPosition);
Color l_oldColor = Gizmos.color;
if (m_instanciatedNavigationNodeEditorComponents.ContainsKey(l_navigationNodeEntry.Key) &&
m_selectedNavigationNodeEditorComponents.Contains(m_instanciatedNavigationNodeEditorComponents[l_navigationNodeEntry.Key]))
{
Gizmos.color = Color.red;
}
Gizmos.DrawWireCube(l_nodePosition, new Vector3(0.2f, 0.2f, 0.2f));
Gizmos.color = l_oldColor;
// Handles.color = new Color(1.0f, 0.5f, 0.0f);
Handles.Label(l_nodePosition + (Vector3.up * 0.35f), l_navigationNodeEntry.Key.ToString());
}
foreach (SerializedNavigationLink l_navigationLink in NavigationGraphAsset.NavigationLinks)
{
Vector3 l_startPosition = l_localToWorldMatrix.MultiplyPoint(NavigationGraphAsset.NavigationNodes[l_navigationLink.StartNode].LocalPosition);
Vector3 l_endPosition = l_localToWorldMatrix.MultiplyPoint(NavigationGraphAsset.NavigationNodes[l_navigationLink.EndNode].LocalPosition);
GizmosHelper.DrawArrow(l_startPosition, l_endPosition, 0.2f);
/*
* if (l_navigationLink.IsDoubleSided)
* {
* l_startPosition = l_localToWorldMatrix.MultiplyPoint(NavigationGraphAsset.NavigationNodes[l_navigationLink.EndNode].LocalPosition);
* l_endPosition = l_localToWorldMatrix.MultiplyPoint(NavigationGraphAsset.NavigationNodes[l_navigationLink.StartNode].LocalPosition);
* GizmosHelper.DrawArrow(l_startPosition, l_endPosition, 0.2f);
* }
*/
}
}
}
}
private void GlobalMoveAlwaysForward()
{
m_motion = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
//print("motion " + m_motion.normalized);
//if (m_motion.sqrMagnitude.Sgn() > 0)
float angleInAFrame = 300 * Time.deltaTime;
if (Vector3.Angle(transform.forward, m_motion) < angleInAFrame * 2)
{
transform.position += m_motion * speed;
transform.forward = m_motion.normalized;
GizmosHelper.DrawLine(transform.position, transform.position + m_motion * 10, Color.blue);
}
else if (m_motion.sqrMagnitude.Sgn() > 0)
{
transform.Rotate(Vector3.up, Vector3.SignedAngle(transform.forward, m_motion, Vector3.up).Sgn() * angleInAFrame);
//transform.forward = Vector3.Slerp(transform.forward, m_motion.normalized, 5f * Time.deltaTime);
//print("angle " + Vector3.Angle(transform.forward, m_motion));
}
}
public void BeatAction()
{
// We check the input after it is not accepted anymore
new ScaledTimer(m_inputAcceptanceDuration / 2f, null, () => {
// if state is waiting, trigger event for some kind of "neutral" failed event
if (m_beats[m_currentBeatIndex].m_first != ButtonType.NONE && m_beats[m_currentBeatIndex].m_second == BeatState.WAITING)
{
OnMissedAction?.Invoke();
GizmosHelper.AddSphere(Vector3.zero, 3, Color.gray, m_beatDuration / 2);
//Debug.Log("Missed");
if (m_beats[m_currentBeatIndex].m_first != ButtonType.DOG1)
{
UpdateScore(-1);
}
FinishCombination();
m_tokens[m_beats[m_currentBeatIndex]].MissedAction();
}
m_currentBeatIndex++;
}).Start();
m_timeAtLastBeat = Time.time;
}
private void OnDrawGizmosSelected()
{
var floorPoint = transform.localPosition.SetZ(0);
if (transform.parent != null)
{
floorPoint = transform.parent.TransformPoint(floorPoint);
}
var hex = GetNearestHex();
if (hex != null)
{
var nearestPos = GetNearestPosition(hex).SetZ(0);
if (transform.parent != null)
{
nearestPos = transform.parent.TransformPoint(nearestPos);
}
Gizmos.color = Color.white;
Gizmos.DrawLine(floorPoint, nearestPos);
Gizmos.color = Color.red;
foreach (var x in GetAnchors(hex))
{
if (transform.parent != null)
{
GizmosHelper.DrawX(transform.parent.TransformPoint(x), X_RADIUS);
}
else
{
GizmosHelper.DrawX(x, X_RADIUS);
}
}
}
Gizmos.color = Color.gray;
Gizmos.DrawLine(transform.position, floorPoint);
}
public static void AddGizmosHelper()
{
GameObject go = Selection.activeGameObject;
if (go != null)
{
GizmosHelper temp = go.GetComponent <GizmosHelper>();
if (temp == null)
{
go.AddComponent <GizmosHelper>();
}
else
{
Debug.Log("help you delete");
DestroyImmediate(temp);
}
}
else
{
GameFramework.Log.Info("You must select a game object first.");
}
}
