public static bool GetStateClickPoint(State state, out Quaternion quaternion)
{
quaternion = default;
if (Event.current.type != EventType.MouseDown || Event.current.button != 0)
{
return(false);
}
GUIUtility.hotControl = GUIUtility.GetControlID(FocusType.Passive);
Event.current.Use();
SphereCollider collider = state.GetComponent <SphereCollider>();
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
ray.origin -= ray.direction * collider.radius * 4;
if (collider.Raycast(ray, out RaycastHit hit, 100.0f))
{
var toCenterDirection = state.transform.position - hit.point;
var rightDirection = Vector3.Cross(toCenterDirection, ray.direction);
var normal = Vector3.Cross(rightDirection, ray.direction);
var hitPosition = state.transform.position + StateEditorWindow.ReflectDirection(toCenterDirection, normal);
Undo.RecordObject(state, "Undo orientation change");
quaternion = Quaternion.FromToRotation(Vector3.forward,
hitPosition - state.transform.position);
return(true);
}
return(false);
}
public void SubstractSphere(Vector3 position, float radius)
{
GameObject boomGhost = new GameObject("BoomGhost");
boomGhost.transform.position = position;
SphereCollider boomGhostCoolider = boomGhost.AddComponent <SphereCollider>();
boomGhostCoolider.radius = radius;
RaycastHit hit;
foreach (var terrainPoint in mesh.Points)
{
var rayFromCore = new Ray(transform.position, terrainPoint.Position - transform.position);
var distanceToCore = Vector3.Distance(terrainPoint.Position, transform.position);
if (boomGhostCoolider.Raycast(rayFromCore, out hit, distanceToCore))
{
terrainPoint.Position = Vector3.Distance(hit.point, transform.position) <= notDestroyableRadius
? Vector3.ClampMagnitude(terrainPoint.Position, notDestroyableRadius)
: hit.point;
}
}
Destroy(boomGhost);
mesh.Flush();
RegenerateCollider();
OnTransformate.Execute();
}
bool BallIsTouched(Touch t)
{
RaycastHit hit = new RaycastHit();
Ray ray = Camera.main.ScreenPointToRay(t.position);
return(ballColl.Raycast(ray, out hit, 1f));
}
private bool IsBeingViewed()
{
if (MLEyes.FixationConfidence < 0.7f)
{
return(false);
}
var fixPoint = MLEyes.FixationPoint;
var headPoint = MainCam.transform.position;
var dir = (fixPoint - headPoint).normalized;
var ray = new Ray(headPoint, dir);
RaycastHit rh;
return(Collider.Raycast(ray, out rh, 10));
}
/// <summary>
/// Calculates if vector is colliding with sphere
/// </summary>
/// <param name="vector">Vector to check</param>
/// <param name="sphereCollider">Sphere collider</param>
/// <returns>Returns true if collides, otherwise false</returns>
public static bool VectorSphereColliderIntersection(
Vector3 vector,
SphereCollider sphereCollider)
{
if (vector.magnitude == 0f)
{
return(false);
}
Ray ray = new Ray(Vector3.zero, vector);
RaycastHit raycastHit;
return(sphereCollider.Raycast(ray, out raycastHit, Int32.MaxValue));
}
private void OnMouseDown()
{
if (_target == null)
{
return;
}
if (_collider.Raycast(_ray) == null)
{
return;
}
_isDragging = true;
_screenPoint = Scene.MainCamera.WorldToScreen(Transform.WorldPosition);
_offset = Transform.WorldPosition - Scene.MainCamera.ScreenToWorld(new Vector3(_mousePosition.X, _mousePosition.Y, _screenPoint.Z));
}
private void OnDrawGizmos()
{
Gizmos.DrawWireSphere(transform.position, planetCollider.radius);
Vector3 point = new Vector3();
Event currentEvent = Event.current;
Vector2 mousePos = new Vector2();
// Get the mouse position from Event.
// Note that the y position from Event is inverted.
if (currentEvent != null)
{
mousePos.x = currentEvent.mousePosition.x;
mousePos.y = cam.pixelHeight - currentEvent.mousePosition.y;
point = cam.ScreenToWorldPoint(new Vector3(mousePos.x, mousePos.y, cam.nearClipPlane));
Ray r = cam.ScreenPointToRay(new Vector3(mousePos.x, mousePos.y, cam.nearClipPlane));
Gizmos.DrawRay(r);
if (Input.GetMouseButton(0))
{
startDrag = true;
Ray spherIntersectRay = new Ray(transform.position, point);
Gizmos.DrawLine(spherIntersectRay.origin, spherIntersectRay.GetPoint(planetCollider.radius));
Gizmos.DrawSphere(spherIntersectRay.GetPoint(planetCollider.radius), 1f);
RaycastHit hit;
Vector3 currentHitPoint = prevHitPos;
if (planetCollider.Raycast(r, out hit, 100f))
{
Gizmos.DrawSphere(hit.point, 1f);
currentHitPoint = hit.point;
}
Quaternion angle = Quaternion.FromToRotation(planetCollider.center - currentHitPoint, planetCollider.center - prevHitPos);
Debug.Log(angle);
Vector3 dir = planetCollider.transform.up - cam.transform.position;
dir = angle * dir;
cam.transform.position = dir + planetCollider.center;
cam.transform.LookAt(planetCollider.center);
prevHitPos = currentHitPoint;
}
else
{
startDrag = false;
}
}
}
private bool CheckRay(Vector3 rayOrigin, Vector3 rayDirection, out Vector3 collisionPoint)
{
SphereCollider worldSphere = GameObject.FindGameObjectWithTag("WorldGrid").collider as SphereCollider;
//Plane worldPlane = new Plane(Vector3.up, Vector3.zero);
Ray ray = new Ray(rayOrigin + 2 * worldSphere.radius * rayDirection, -rayDirection);
RaycastHit info;
if (worldSphere.Raycast(ray, out info, 2 * worldSphere.radius))
{
collisionPoint = info.point;
return(true);
}
collisionPoint = Vector2.zero;
return(false);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonUp(0))
{
//prevHitPos = Input.mousePosition;
released = true;
}
if (Input.GetMouseButton(0))
{
Vector3 mousePos = Input.mousePosition;
Ray r = cam.ScreenPointToRay(mousePos);
Debug.DrawRay(r.origin, r.direction);
RaycastHit hit;
Vector3 currentHitPoint = prevHitPos;
if (planetCollider.Raycast(r, out hit, 100f))
{
currentHitPoint = hit.point;
if (released)
{
prevHitPos = currentHitPoint;
released = false;
}
}
Quaternion angleDelta = Quaternion.FromToRotation(currentHitPoint - planetCollider.center, prevHitPos - planetCollider.center);
Debug.DrawLine(prevHitPos, currentHitPoint);
Debug.DrawRay(planetCollider.center, (currentHitPoint - planetCollider.center) * 2, Color.red);
newCamPos = angleDelta * newCamPos;
Debug.DrawRay(planetCollider.center, newCamPos - planetCollider.center, Color.blue);
float fracComplete = (Time.time - startTime) / journeyTime;
newCamPos = Vector3.Slerp(newCamPos, cam.transform.position, fracComplete);
cameraDummy.transform.position = newCamPos;
cameraDummy.transform.LookAt(planetCollider.center);
cam.transform.position = newCamPos;
cam.transform.LookAt(planetCollider.center);
prevHitPos = currentHitPoint;
}
}
private void updateMapView()
{
if (!MapView.MapIsEnabled || !showOverlay || MapView.MapCamera == null)
{
gameObject.renderer.enabled = false;
return;
}
gameObject.renderer.enabled = true;
var target = MapView.MapCamera.target;
var newBody = getTargetBody(target);
var bodyChanged = newBody != body;
if (bodyChanged)
{
body = newBody;
var radius = bodyRadii.ContainsKey(body) ? bodyRadii[body] : 1.025;
gameObject.transform.parent = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == body.name);
gameObject.transform.localScale = Vector3.one * 1000f * (float)radius;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localRotation = Quaternion.identity;
}
if (bodyChanged || resource == null || resource.Resource != KethaneController.SelectedResource)
{
resource = KethaneController.ResourceDefinitions.Where(r => r.Resource == KethaneController.SelectedResource).Single().ForBody(body);
refreshCellColors();
}
var ray = MapView.MapCamera.camera.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (gridCollider.Raycast(ray, out hitInfo, float.PositiveInfinity))
{
hoverCell = grid.NearestCell(gameObject.transform.InverseTransformPoint(hitInfo.point));
}
else
{
hoverCell = null;
}
}
void OnSceneGUI()
{
if (Event.current.type == EventType.MouseDown)
{
SplineDrawer drawer = target as SplineDrawer;
Transform t = drawer.transform;
if (Selection.activeTransform != t)
{
bool inChildren = false;
foreach (Transform v in t)
{
if (Selection.activeTransform == v)
{
inChildren = true;
}
}
if (!inChildren)
{
return;
}
}
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
GameObject o = new GameObject();
SphereCollider sp = o.AddComponent <SphereCollider>();
sp.radius = 0.5f;
RaycastHit hit;
foreach (Transform v in t)
{
o.transform.position = v.position;
if (sp.Raycast(ray, out hit, float.MaxValue))
{
GUIUtility.hotControl = 0;
Selection.activeTransform = v;
}
}
DestroyImmediate(o);
}
}
void Update()
{
Vector3[] vertices = m_mesh.vertices;
Color[] colors = new Color[vertices.Length];
float scaledMinDia = transform.localScale.x * m_minDiameter;
Vector3 prevPos = sphereCol.transform.position;
sphereCol.transform.position = sphereCol.transform.position - transform.position;
sphereCol.transform.position = Quaternion.Inverse(transform.rotation) * sphereCol.transform.position;
for (int i = 0; i < vertices.Length; i++)
{
Vector3 scaledVertice = transform.localScale.x * vertices[i];
float magnitude = scaledVertice.magnitude;
RaycastHit hit;
m_ray.direction = m_normals[i];
m_ray.origin = Vector3.zero;
if (sphereCol.Raycast(m_ray, out hit, magnitude))
{
if (hit.point.sqrMagnitude < scaledVertice.sqrMagnitude)
{
float scaleFactor = (hit.point - sphereCol.transform.position).sqrMagnitude;
vertices[i] = (Mathf.Max(scaledMinDia, magnitude - m_speed * scaleFactor) * m_normals[i]) / transform.localScale.x;
}
}
colors[i] = m_color;
}
m_mesh.vertices = vertices;
m_mesh.colors = colors;
m_mesh.RecalculateNormals();
sphereCol.transform.position = prevPos;
}
private static void SceneGui(SceneView sceneView)
{
if (!EditableItem || !EditableState)
{
return;
}
Handles.color = CubeColor;
Handles.DrawWireCube(
EditableState.transform.position + EditableItem.orientation * Vector3.forward,
Vector3.one * 0.2f
);
if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
GUIUtility.hotControl = GUIUtility.GetControlID(FocusType.Passive);
Event.current.Use();
SphereCollider collider = EditableState.GetComponent <SphereCollider>();
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
//if ((state.transform.position - ray.origin).magnitude <= collider.radius * collider.radius)
ray.origin -= ray.direction * collider.radius * 4;
if (collider.Raycast(ray, out RaycastHit hit, 100.0f))
{
var toCenterDirection = EditableState.transform.position - hit.point;
var rightDirection = Vector3.Cross(toCenterDirection, ray.direction);
var normal = Vector3.Cross(rightDirection, ray.direction);
var hitPosition = EditableState.transform.position + StateEditorWindow.ReflectDirection(toCenterDirection, normal);
Undo.RecordObject(EditableItem, "Undo orientation change");
EditableItem.orientation = Quaternion.FromToRotation(Vector3.forward,
hitPosition - EditableState.transform.position);
}
}
}
public override RuntimeHandleAxis HitTest(Ray ray, out float distance)
{
if (!m_useColliders)
{
distance = float.PositiveInfinity;
return(RuntimeHandleAxis.None);
}
Collider collider = null;
float minDistance = float.MaxValue;
if (m_isVertexSnapping)
{
RaycastHit hit;
if (m_snappingCollider.Raycast(ray, out hit, Window.Camera.farClipPlane))
{
collider = hit.collider;
minDistance = hit.distance;
}
}
else
{
for (int i = 0; i < m_colliders.Length; ++i)
{
RaycastHit hit;
if (m_colliders[i].Raycast(ray, out hit, Window.Camera.farClipPlane))
{
if (m_lockObj.PositionX)
{
if (hit.collider == m_xCollider || hit.collider == m_xyCollider || hit.collider == m_xzCollider)
{
continue;
}
}
if (m_lockObj.PositionY)
{
if (hit.collider == m_yCollider || hit.collider == m_yzCollider || hit.collider == m_xyCollider)
{
continue;
}
}
if (m_lockObj.PositionZ)
{
if (hit.collider == m_zCollider || hit.collider == m_yzCollider || hit.collider == m_xzCollider)
{
continue;
}
}
if (hit.distance < minDistance)
{
collider = hit.collider;
minDistance = hit.distance;
}
}
}
}
distance = minDistance;
if (collider == m_xCollider)
{
return(RuntimeHandleAxis.X);
}
if (collider == m_yCollider)
{
return(RuntimeHandleAxis.Y);
}
if (collider == m_zCollider)
{
return(RuntimeHandleAxis.Z);
}
if (collider == m_xyCollider)
{
return(RuntimeHandleAxis.XY);
}
if (collider == m_xzCollider)
{
return(RuntimeHandleAxis.XZ);
}
if (collider == m_yzCollider)
{
return(RuntimeHandleAxis.YZ);
}
if (collider == m_snappingCollider)
{
return(RuntimeHandleAxis.Snap);
}
distance = float.PositiveInfinity;
return(RuntimeHandleAxis.None);
}
public override RuntimeHandleAxis HitTest(Ray ray)
{
if (!m_useColliders)
{
return(RuntimeHandleAxis.None);
}
Collider collider = null;
float minDistance = float.MaxValue;
// m_xCollider.transform.gameObject.SetActive(true);
if (m_isVertexSnapping)
{
RaycastHit hit;
if (m_snappingCollider.Raycast(ray, out hit, Window.Camera.farClipPlane))
{
collider = hit.collider;
minDistance = hit.distance;
}
}
else
{
for (int i = 0; i < m_colliders.Length; ++i)
{
RaycastHit hit;
if (m_colliders[i].Raycast(ray, out hit, Window.Camera.farClipPlane))
{
if (hit.distance < minDistance)
{
collider = hit.collider;
minDistance = hit.distance;
}
}
}
}
//m_xCollider.transform.gameObject.SetActive(false);
if (collider == m_xCollider)
{
return(RuntimeHandleAxis.X);
}
if (collider == m_yCollider)
{
return(RuntimeHandleAxis.Y);
}
if (collider == m_zCollider)
{
return(RuntimeHandleAxis.Z);
}
if (collider == m_xyCollider)
{
return(RuntimeHandleAxis.XY);
}
if (collider == m_xzCollider)
{
return(RuntimeHandleAxis.XZ);
}
if (collider == m_yzCollider)
{
return(RuntimeHandleAxis.YZ);
}
if (collider == m_snappingCollider)
{
return(RuntimeHandleAxis.Snap);
}
return(RuntimeHandleAxis.None);
}
