using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Line_Line_Collision : MonoBehaviour {
    public Transform LineStart1;
    public Transform LineEnd1;
    public Transform LineStart2;
    public Transform LineEnd2;

    private void OnDrawGizmos()
    {
        /*
            이 방법으로는 수직인 직선의 기울기가 0 또는 무한대가 되므로 교점을 찾을 수 없다.
        */

        // 직선의 방정식 : y = ax + b, y = cx + d
        // x` = (d - b) / (a - c)
        // y` = ax` + b
        float a = (LineEnd1.position.y - LineStart1.position.y) / (LineEnd1.position.x - LineStart1.position.x);
        float c = (LineEnd2.position.y - LineStart2.position.y) / (LineEnd2.position.x - LineStart2.position.x);
        float b = LineEnd1.position.y - a * LineEnd1.position.x;
        float d = LineEnd2.position.y - c * LineEnd2.position.x;

        if(a == c && b == d)
        {
            Debug.Log("Overlap");
            return;
        } else if (a == c)
        {
            Debug.Log("Parallel");
            return;
        } else
        {
            Debug.Log("Collision");
        }

        float x = (d - b) / (a - c);
        float y = a * x + b;

        Gizmos.color = Color.red;
        Gizmos.DrawLine(LineStart1.position, LineEnd1.position);
        Gizmos.color = Color.blue;
        Gizmos.DrawLine(LineStart2.position, LineEnd2.position);
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(new Vector3(x, y, 0), 1);

        Debug.Log(x + ", " + y);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Segment_Segment_Collision : MonoBehaviour
{
    public Transform P1;
    public Transform P2;
    public Transform Q1;
    public Transform Q2;

    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawLine(P1.position, P2.position);
        Gizmos.color = Color.blue;
        Gizmos.DrawLine(Q1.position, Q2.position);

        Vector3 p1 = P1.position;
        Vector3 p2 = P2.position;
        Vector3 q1 = Q1.position;
        Vector3 q2 = Q2.position;

        Vector3 v = P2.position - P1.position;
        Vector3 w = Q2.position - Q1.position;

        float denominator = (q2.x - q1.x) * (p1.y - p2.y) - (p1.x - p2.x) * (q2.y - q1.y);

        if(denominator == 0)
        {
            Debug.Log("Overlap");
            return;
        }

        // t : P1->P2에서 교점의 비율, s : Q1->Q2에서 교점의 비율
        float t = ((q1.y - q2.y) * (p1.x - q1.x) + (q2.x - q1.x) * (p1.y - q1.y)) / denominator;
        float s = ((p1.y - p2.y) * (p1.x - q1.x) + (p2.x - p1.x) * (p1.y - q1.y)) / denominator;

        float x = v.x * t + p1.x;
        float y = v.y * t + p1.y;

        Debug.Log(t + ", " + s + ", " + denominator);

        if (t < 0.0f || t > 1.0f || s < 0.0f || s > 1.0f)
        {
            Debug.Log("No Collision");
        }
        else if (t == 0 && s == 0)
        {
            Debug.Log("Parallel");
        }
        else
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(new Vector3(x, y, 0), 1);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Segment_Sphere_Collision : MonoBehaviour
{
    public Transform P1;
    public Transform P2;
    public Transform Sphere;

    private void OnDrawGizmos()
    {
        Vector3 s = Sphere.position;
        float r = Sphere.localScale.x * 0.5f;
        Vector3 p = P1.position;
        Vector3 v = P2.position - P1.position;

        Vector3 k = new Vector3(p.x - s.x, p.y - s.y, p.z - s.z);

        // ax^2 + 2bx + c = 0
        float a = Mathf.Pow(v.x, 2) + Mathf.Pow(v.y, 2) + Mathf.Pow(v.z, 2);
        float b = k.x * v.x + k.y * v.y + k.z * v.z;
        float c = Mathf.Pow(k.x, 2) + Mathf.Pow(k.y, 2) + Mathf.Pow(k.z, 2) - Mathf.Pow(r, 2);

        Gizmos.color = Color.blue;
        Gizmos.DrawLine(p, p + v);

        // 판별식
        float d = Mathf.Pow(b, 2) - (a * c);
        if(d < 0) // 근이 없다
        {
            return;
        }

        // 근의 공식
        float t1 = (-b + Mathf.Sqrt(d)) / a;
        float t2 = (-b - Mathf.Sqrt(d)) / a;

        Debug.Log(t1 + ", " + t2);

        if (t1 >= 0f && t1 <= 1f)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(new Vector3(v.x * t1 + p.x, v.y * t1 + p.y, v.z * t1 + p.z), 1);
        }

        if (t2 >= 0f && t2 <= 1f)
        {
            Gizmos.color = Color.green;
            Gizmos.DrawWireSphere(new Vector3(v.x * t2 + p.x, v.y * t2 + p.y, v.z * t2 + p.z), 1);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Segment_Plane_Collision : MonoBehaviour
{
    public Transform Plane;
    public Transform SegmentStart;
    public Transform SegmentEnd;

    private void OnDrawGizmos()
    {
        /*
        법선 벡터 : N(Nx, Ny, Nz)
        평면상의 한 점 : P(Px, Py, Pz)
        평면의 방정식 : Nx*x + Ny*y + Nz*z + d = 0
                      d = -N·Q = -(Nx*Px + Ny*Py + Nz*Pz)
        */
        Vector3 n = Plane.up.normalized; // 평면의 법선 벡터
        Vector3 p = Plane.position; // 평면상의 한 점
        Vector3 s = SegmentStart.position; // 선분의 시작점

        // d값은 변하지 않기 때문에 미리 계산하는게 좋다.
        float d = -(n.x * p.x + n.y * p.y + n.z * p.z);
        // 선분의 시작점과 평면의 거리
        float distance = n.x * s.x + n.y * s.y + n.z * s.z + d; // 평면의 방정식의 근

        // 평면의 방정식의 근이 0보다 작을 경우 공간상의 점은 평면 법선 벡터가 있는 쪽의 반대쪽에 있다.
        if(distance < 0)
        {
            n *= -1; // 선분의 시작점이 법선 벡터 반대쪽에 있으므로 법선 벡터를 뒤집어 준다.
            distance *= -1; // 거리에서 방향 정보를 제거한다.
        }

        // 공간 상의 점과 평면을 연결하는 가장 짧은 벡터
        Vector3 shortestVector = n * distance;
        // 선분 벡터
        Vector3 segment = SegmentEnd.position - SegmentStart.position;
        // 평면의 법선 벡터와 선분의 각도
        float cos = Vector3.Dot(-n, segment.normalized);

        // 선분과 평면의 각도가 0~90 사이일 경우만 계산한다.
        // 90~180 사이에서는 선분의 방향으로 절대 만나지 않는다.
        if (cos > 0)
        {
            // 선분의 시작에서 평면까지의 거리
            float distanceFromStartToPlane = distance / cos;
            // 선분의 시작에서 평면까지의 벡터
            Vector3 toPlane = segment.normalized * distanceFromStartToPlane;

            Debug.Log(distanceFromStartToPlane + ", " + segment.magnitude);

            // 제곱근 연산은 부하가 크기 때문에 길이의 제곱으로 비교한다.
            //if (distanceFromStartToPlane <= segment.magnitude)
            if (Mathf.Pow(distanceFromStartToPlane, 2) <= segment.sqrMagnitude)
            {
                Gizmos.color = Color.yellow;
                Gizmos.DrawWireSphere(SegmentStart.position + toPlane, 1);

                Gizmos.color = Color.cyan; // 선분과 평면이 충돌함
            }
            else
            {
                Gizmos.color = Color.red; // 선분과 평면이 충돌하지 않음
            }
        } else
        {
            Gizmos.color = Color.red; // 선분과 평면이 충돌하지 않음
        }
        
        Gizmos.DrawLine(SegmentStart.position, SegmentEnd.position);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Segment_Triangle_Collision : MonoBehaviour
{
    public Transform T1;
    public Transform T2;
    public Transform T3;
    public Transform SP1;
    public Transform SP2;

    private void OnDrawGizmos()
    {
        /*
        법선 벡터 : N(Nx, Ny, Nz)
        평면상의 한 점 : P(Px, Py, Pz)
        평면의 방정식 : Nx*x + Ny*y + Nz*z + d = 0
                      d = -N·Q = -(Nx*Px + Ny*Py + Nz*Pz)
        */
        // 삼각형 선분 벡터
        Vector3 tv12 = T2.position - T1.position;
        Vector3 tv23 = T3.position - T2.position;
        Vector3 tv31 = T1.position - T3.position;

        Gizmos.color = Color.white;
        Gizmos.DrawLine(T1.position, T2.position);
        Gizmos.DrawLine(T2.position, T3.position);
        Gizmos.DrawLine(T3.position, T1.position);

        Vector3 tn = Vector3.Cross(tv12, tv23); // 삼각형의 법선 벡터(triangle normal)
        Vector3 tp = T1.position; // 삼각형 위의 한 점(triangle point)
        Vector3 sp = SP1.position; // 선분의 시작점(start or segment point)

        // d값은 변하지 않기 때문에 미리 계산하는게 좋다.
        float d = -(tn.x * tp.x + tn.y * tp.y + tn.z * tp.z);
        // 선분의 시작점과 평면의 거리
        float distance = tn.x * sp.x + tn.y * sp.y + tn.z * sp.z + d; // 평면의 방정식의 근(평면과 점의 거리)

        // 평면의 방정식의 근이 0보다 작을 경우 공간상의 점은 평면 법선 벡터가 있는 쪽의 반대쪽에 있다.
        if (distance < 0)
        {
            tn *= -1; // 선분의 시작점이 법선 벡터 반대쪽에 있으므로 법선 벡터를 뒤집어 준다.
            distance *= -1; // 거리에서 방향 정보를 제거한다.
        }

        // 공간 상의 점과 평면을 연결하는 가장 짧은 벡터
        Vector3 shortestVector = tn * distance;
        // 선분 벡터(segment vector)
        Vector3 sv = SP2.position - SP1.position;
        // 평면의 법선 벡터와 선분의 각도
        float cos = Vector3.Dot(-tn, sv.normalized);

        // 선분과 평면의 각도가 0~90 사이일 경우만 계산한다.
        // 90~180 사이에서는 선분의 방향으로 절대 만나지 않는다.
        if (cos > 0)
        {
            // 선분의 시작에서 평면까지의 거리
            float distanceFromStartToPlane = distance / cos;
            // 선분의 시작에서 평면까지의 벡터(intersection point vector)
            Vector3 ipv = sv.normalized * distanceFromStartToPlane;

            // 제곱근 연산은 부하가 크기 때문에 길이의 제곱으로 비교한다.
            if (Mathf.Pow(distanceFromStartToPlane, 2) <= sv.sqrMagnitude)
            {
                Gizmos.color = Color.yellow;
                Gizmos.DrawWireSphere(SP1.position + ipv, 1);

                // 각 변과 충돌 지점에서 각 꼭지점으로 이은 선을 외적하여 나온 벡터들을 
                // 서로 내적하여 모두 같은 값이면 삼각형 안에 있다고 판단
                Vector3 ip = SP1.position + ipv; // 충돌 지점(intersection point)
                Vector3 n1 = Vector3.Cross(tv31, T1.position - ip).normalized;
                Vector3 n2 = Vector3.Cross(tv12, T2.position - ip).normalized;
                Vector3 n3 = Vector3.Cross(tv23, T3.position - ip).normalized;

                Gizmos.color = Color.green;
                Gizmos.DrawLine(T1.position, T1.position + n1);
                Gizmos.DrawLine(T2.position, T2.position + n2);
                Gizmos.DrawLine(T3.position, T3.position + n3);

                Gizmos.color = Color.yellow;
                Gizmos.DrawLine(T1.position, ip);
                Gizmos.DrawLine(T2.position, ip);
                Gizmos.DrawLine(T3.position, ip);

                // 내적이 1이면 같은 방향
                Debug.Log(Vector3.Dot(n1, n2) + ", " + Vector3.Dot(n2, n3));
                if (Vector3.Dot(n1, n2) == 1f && Vector3.Dot(n2, n3) == 1f)
                {
                    Gizmos.color = Color.cyan; // 선분과 삼각형이 충돌함
                }
                else
                {
                    Gizmos.color = Color.red; // 선분과 삼각형이 충돌하지 않음
                }
            }
            else
            {
                Gizmos.color = Color.red; // 선분과 삼각형이 충돌하지 않음
            }
        }
        else
        {
            Gizmos.color = Color.red; // 선분과 삼각형이 충돌하지 않음
        }

        Gizmos.DrawLine(SP1.position, SP2.position);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Sphere_Sphere_Collision : MonoBehaviour {
    public Transform S1;
    public Transform S2;

    private void OnDrawGizmos()
    {
        Vector3 sp1 = S1.position;
        Vector3 sp2 = S2.position;

        float r1 = S1.localScale.x * 0.5f;
        float r2 = S2.localScale.x * 0.5f;

        Vector3 v = sp2 - sp1;
        if (v.sqrMagnitude < Mathf.Pow(r1 + r2, 2))
        {
            Gizmos.color = Color.blue;

            // 침범한 만큼 밀어내기
            // 침범한 거리(invasion distance)
            float idst = (r1 + r2) - v.magnitude;
            S1.position += -v.normalized * idst;
        } else
        {
            Gizmos.color = Color.red;
        }

        Gizmos.DrawLine(sp1, sp2);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Sphere_Triangle_Collision : MonoBehaviour
{
    public Transform T1;
    public Transform T2;
    public Transform T3;
    public Transform SP;

    private void OnDrawGizmos()
    {
        // 삼각형 선분 벡터(triangle vector)
        Vector3 tv12 = T2.position - T1.position;
        Vector3 tv23 = T3.position - T2.position;
        Vector3 tv31 = T1.position - T3.position;

        Gizmos.color = Color.white;
        Gizmos.DrawLine(T1.position, T2.position);
        Gizmos.DrawLine(T2.position, T3.position);
        Gizmos.DrawLine(T3.position, T1.position);

        Vector3 tn = Vector3.Cross(tv12, tv23).normalized; // 삼각형의 법선 벡터(triangle normal)
        Vector3 pp = T1.position; // 평면 위의 한 점(plane point)
        Vector3 sp = SP.position; // 구의 중심(sphere point)
        float r = SP.localScale.x * 0.5f; // 구의 반지름(radius)

        // d값은 변하지 않기 때문에 미리 계산하는게 좋다.
        float d = -(tn.x * pp.x + tn.y * pp.y + tn.z * pp.z); // 평면의 방정식에서 d값
        // 구의 중심과 평면의 거리
        float distance = tn.x * sp.x + tn.y * sp.y + tn.z * sp.z + d; // 평면의 방정식의 근(평면과 점의 거리)

        // 평면의 방정식의 근이 0보다 작을 경우 공간상의 점은 평면 법선 벡터가 있는 쪽의 반대쪽에 있다.
        if (distance < 0)
        {
            tn *= -1; // 선분의 시작점이 법선 벡터 반대쪽에 있으므로 법선 벡터를 뒤집어 준다.
            distance *= -1; // 거리에서 방향 정보를 제거한다.
        }

        // 1. 구와 삼각형이 있는 평면과 충돌 검사 //
        {
            if (distance > r)
            {
                return;
            }
        }

        // 2. 구와 삼각형 각 변의 충돌 검사 //
        {
            bool isCollided = false;

            Vector3[] tps = { T1.position, T2.position, T3.position };
            Vector3[] tvs = { tv12, tv23, tv31 };
            for (int i = 0; i < 3; i++)
            {
                Vector3 tp = tps[i];
                Vector3 tv = tvs[i];
                Vector3 k = new Vector3(tp.x - sp.x, tp.y - sp.y, tp.z - sp.z);

                // ax^2 + 2bx + c = 0
                float a = Mathf.Pow(tv.x, 2) + Mathf.Pow(tv.y, 2) + Mathf.Pow(tv.z, 2);
                float b = k.x * tv.x + k.y * tv.y + k.z * tv.z;
                float c = Mathf.Pow(k.x, 2) + Mathf.Pow(k.y, 2) + Mathf.Pow(k.z, 2) - Mathf.Pow(r, 2);

                // 판별식(discriminant)
                float dis = Mathf.Pow(b, 2) - (a * c);
                if (dis >= 0) // 근이 있다.
                {
                    isCollided = true;

                    // 근의 공식
                    float t1 = (-b + Mathf.Sqrt(dis)) / a;
                    float t2 = (-b - Mathf.Sqrt(dis)) / a;

                    Debug.Log(t1 + ", " + t2);

                    if (t1 >= 0f && t1 <= 1f)
                    {
                        Gizmos.color = Color.yellow;
                        Gizmos.DrawWireSphere(new Vector3(tv.x * t1 + tp.x, tv.y * t1 + tp.y, tv.z * t1 + tp.z), 0.2f);
                    }

                    if (t2 >= 0f && t2 <= 1f)
                    {
                        Gizmos.color = Color.green;
                        Gizmos.DrawWireSphere(new Vector3(tv.x * t2 + tp.x, tv.y * t2 + tp.y, tv.z * t2 + tp.z), 0.2f);
                    }
                }

                if (isCollided) break;
            }

            if (isCollided)
            {
                Gizmos.color = Color.cyan;
                Gizmos.DrawWireSphere(sp, r * 1.2f);
                return;
            }
        }

        // 3. 구가 삼각형 안에 들어갔는지 검사 //
        {
            // 구의 중심에서 삼각형에 수직으로 내린 직선 벡터(vertical vector)
            Vector3 vv = tn * distance;

            Vector3 ip = SP.position - vv; // 충돌 지점(intersection point)
            Vector3 n1 = Vector3.Cross(tv31, T1.position - ip).normalized;
            Vector3 n2 = Vector3.Cross(tv12, T2.position - ip).normalized;
            Vector3 n3 = Vector3.Cross(tv23, T3.position - ip).normalized;

            Gizmos.color = Color.green;
            Gizmos.DrawLine(T1.position, T1.position + n1);
            Gizmos.DrawLine(T2.position, T2.position + n2);
            Gizmos.DrawLine(T3.position, T3.position + n3);

            Gizmos.color = Color.yellow;
            Gizmos.DrawLine(T1.position, ip);
            Gizmos.DrawLine(T2.position, ip);
            Gizmos.DrawLine(T3.position, ip);

            // 내적이 1이면 같은 방향
            Debug.Log(Vector3.Dot(n1, n2) + ", " + Vector3.Dot(n2, n3));
            if (Vector3.Dot(n1, n2) >= 0.0f && Vector3.Dot(n2, n3) >= 0.0f)
            {
                Gizmos.color = Color.cyan; // 구가 삼각형 안에 있음
            }
            else
            {
                Gizmos.color = Color.red; // 구가 삼각형 안에 없음
            }

            Gizmos.DrawLine(SP.position, SP.position + vv);
            Gizmos.DrawWireSphere(SP.position, r*1.2f);
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Plane_Plane_Collision : MonoBehaviour {
    public Transform P0;
    public Transform P1;

    private void OnDrawGizmos()
    {
        Vector3 p0 = P0.position;
        Vector3 p1 = P1.position;

        // 평면의 법선
        Vector3 n0 = P0.up.normalized;
        Vector3 n1 = P1.up.normalized;

        // 평면의 방정식의 d값
        float d0 = -1 * Vector3.Dot(n0, p0);
        float d1 = -1 * Vector3.Dot(n1, p1);

        // 교선 벡터
        Vector3 v = Vector3.Cross(P0.up, P1.up);
        Debug.Log(v);

        // 시작점
        float x = 0;
        float y = 0;
        float z = 0;
        if (v.z != 0.0f)
        {
            x = (n0.y * d1 - n1.y * d0) / v.z;
            y = (n1.x * d0 - n0.x * d1) / v.z;
            z = 0f;
        }
        else if (v.y != 0.0f)
        {
            x = (n1.z * d0 - n0.z * d1) / v.y;
            y = 0f;
            z = (n1.y * d0 - n0.y * d1) / v.z;
        }
        else if (v.x != 0.0f)
        {
            x = 0f;
            y = (n0.z * d1 - n1.z * d0) / v.x;
            z = (n1.y * d0 - n0.y * d1) / v.x;
        }
        Vector3 sp = new Vector3(x, y, z);

        Gizmos.color = Color.green;
        Gizmos.DrawLine(p0, p0 + P0.up);
        Gizmos.DrawLine(p1, p1 + P1.up);
        Gizmos.color = Color.magenta;
        Gizmos.DrawWireMesh(P0.gameObject.GetComponent<MeshFilter>().mesh, P0.position, P0.rotation, P0.localScale);

        Gizmos.color = Color.white;
        Gizmos.DrawLine(Vector3.zero, v*100000f);
        Gizmos.DrawLine(Vector3.zero, -v*100000f);

        Gizmos.color = Color.red;
        Gizmos.DrawLine(sp, sp + v * 100000f);
        Gizmos.DrawLine(sp, sp + -v * 100000f);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Plane_Triangle_Collision : MonoBehaviour
{
    public Transform T0;
    public Transform T1;
    public Transform T2;
    public Transform P; // Plane

    private void OnDrawGizmos()
    {
        Vector3 p = P.position;
        Vector3 t0 = T0.position;
        Vector3 t1 = T1.position;
        Vector3 t2 = T2.position;

        // 평면의 법선
        Vector3 n = P.up;

        // 평면의 방정식의 d값
        float d = -1 * Vector3.Dot(n, p);

        float distance0 = n.x * t0.x + n.y * t0.y + n.z * t0.z + d;
        float distance1 = n.x * t1.x + n.y * t1.y + n.z * t1.z + d;
        float distance2 = n.x * t2.x + n.y * t2.y + n.z * t2.z + d;

        Debug.Log(distance0 + ", " + distance1 + ", " + distance2);

        Color color = Color.white;

        // 모두 같은 부호이면 같은 면에 있다. - 충돌 안함
        // 하나라도 부호가 다르면 다른 면에 있다. - 충돌함.
        if (distance0 * distance1 <= 0 || distance1 * distance2 <= 0)
        {
            // 충돌한 지점 찾기
            Vector3[] ts = { t0, t1, t2 }; // 꼭지점 위치
            Vector3[] tvs = { t1 - t0, t2 - t1, t0 - t2 }; // 변
            float[] distances = { distance0, distance1, distance2 }; // 꼭지점과 평면의 거리

            for (int i = 0; i < tvs.Length; i++)
            {
                Vector3 tv = tvs[i];
                Vector3 tvn = tv.normalized;
                float distance = distances[i];

                if (distance > 0 && Vector3.Dot(n, tvn) > 0) continue; // 변이 평면 위에 있고 평면을 향하고 있지 않다.
                if (distance < 0 && Vector3.Dot(n, tvn) < 0) continue; // 변이 평면 아래에 있고 평면을 향하고 있지 않다.

                distance = Mathf.Abs(distance); // 평면 위, 아래 판단 후 절대값으로 만들어 방향 정보를 제거한다.
                float cos = Mathf.Abs(Vector3.Dot(tvn, n)); // cos의 절대값은 예각이다.
                float l = distance / cos; // 꼭지점에서 변의 방향으로 평면에 닿을 때까지의 거리

                if (l >= 0f && Mathf.Pow(l, 2) <= tv.sqrMagnitude) // 이 변이 평면과 충돌
                {
                    Vector3 v = tvn * l; // 꼭지점에서 평면에 닿을 때까지의 벡터
                    Gizmos.color = Color.yellow;
                    Gizmos.DrawWireSphere(ts[i] + v, 0.5f);
                }
            }

            Gizmos.color = Color.red;
        }

        Gizmos.DrawLine(T0.position, T1.position);
        Gizmos.DrawLine(T1.position, T2.position);
        Gizmos.DrawLine(T2.position, T0.position);

        Gizmos.color = Color.yellow;
        Gizmos.DrawLine(P.position, P.position + P.up * 5f);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// 삼각형 클래스 정의 --- 시작
[System.Serializable]
public class Triangle
{
    public Transform[] Vertices; // 꼭짓점
    public Vector3[] Segments; // 선분
    public Vector3 N; // 법선 벡터
    public Color[] SegmentColors = new Color[3]; // 각 선분의 색상, 충돌한 선분은 다른 색으로 칠해준다.

    private float _d; // 평면의 방정식의 d

    // 삼각형을 초기화한다
    public void Init()
    {
        if (Segments == null || Segments.Length < Vertices.Length) Segments = new Vector3[Vertices.Length];

        Segments[0] = Vertices[1].position - Vertices[0].position; // 0->1로 향하는 벡터
        Segments[1] = Vertices[2].position - Vertices[1].position; // 1->2로 향하는 벡터
        Segments[2] = Vertices[0].position - Vertices[2].position; // 2->0로 향하는 벡터

        N = Vector3.Cross(Segments[0], Segments[1]).normalized; // 평면의 법선(노멀) 벡터는 자주사용하므로 미리 계산

        _d = -(Vector3.Dot(N, Vertices[0].position)); // 평면의 방정식의 d값은 자주 사용하므로 미리 계산

        for (int i = 0; i < SegmentColors.Length; i++)
        {
            SegmentColors[i] = Color.black; // 충돌하지 않은 선분 기본 색상 초기화
        }
    }

    // 현재 삼각형을 평면으로 하여 매개변수로 전달된 선분과 충돌했는지 테스트한다.
    // 선분에서 충돌한 지점을 선분 길이 대비 비율로 반환한다.(직선의 매개변수 방정식에서 t)
    // 0~1 사이 : 충돌 지점이 선분 안이다. 충돌했다.
    // 0~1 바깥 : 충돌 지점이 선분 밖이다. 충돌 안했다.
    public float HitTestWithSegment(Vector3 position, Vector3 vector)
    {
        // 평면과 선분 시작점의 거리
        float distance = N.x * position.x + N.y * position.y + N.z * position.z + _d;
        // 선분의 방향을 나타내는 단위벡터
        Vector3 vn = vector.normalized;
        // 반환할 충돌지점 비율값(직선의 매개변수 방정식에서 t)
        float t = -1f;
        // 평면의 법선과 선분의 내적값, 두 벡터 사이각의 cos값과 같다.
        float cos = Vector3.Dot(N, vn);

        // 평면과 시작점의 거리가 양수이면 시작점은 평면의 법선벡터 방향(평면의 위)에 있고,
        // 음수이면 평면의 법선벡터 반대 방향(평면 아래)에 있다.
        if (distance > 0 && cos > 0) return t; // 평면 위에 있고 평면을 향하지 않는다. 충돌 가능성 없음.
        if (distance < 0 && cos < 0) return t; // 평면 아래에 있고 평면을 향하지 않는다. 충돌 가능성 없음.

        distance = Mathf.Abs(distance); // 거리에서 방향성을 제거하기 위해 부호를 제거한다.
        cos = Mathf.Abs(cos); // 예각을 구하기 위해 절대값으로 변경(cos값에서 부호를 제거하면 언제나 0~90사이를 가리키는 예각이 된다.)

        // 두 벡터의 내각, 즉 cos값이 0이라는 것은 두 벡터가 90도로 직교한다는 것이고 이는 
        // 평면의 법선과 선분이 90도라는 것이다.
        // 즉, 평면과 선분은 평행하므로 충돌 가능성이 없다.
        if (Mathf.Approximately(cos, 0f)) return t;

        // 시작점에서 평면에 내린 수선(평면에 직교하는 선 = 인접변)의 길이와 
        // 두 벡터의 cos값으로 빗변의 길이를 알아낸다.
        float hypotenuse = distance / cos;
        // 빗변의 길이와 선분의 길이의 비율을 계산한다.
        t = hypotenuse / vector.magnitude;

        return t;
    }

    // 선분을 모두 그린다.
    public void DrawSegments()
    {
        for (int i = 0; i < Segments.Length; i++)
        {
            Gizmos.color = SegmentColors[i];
            Gizmos.DrawLine(Vertices[i].position, Vertices[(i + 1) % Segments.Length].position);
        }
    }
}
/// 삼각형 클래스 정의 --- 끝

public class Triangle_Triangle_Collision : MonoBehaviour {
    public Triangle t0; // 삼각형1
    public Triangle t1; // 삼각형2

    private Color[] _crossVectorColors = { Color.red, Color.blue, Color.green };

    private void OnDrawGizmos()
    {
        // 삼각형을 초기화한다.
        t0.Init();
        t1.Init();

        // t0을 평면으로 하여 충돌 테스트를 한다.
        bool hit = HitTestTriangle(t0, t1);
        // 충돌하지 않았으면 t1을 평면으로 하여 충돌 테스트를 한 번 더 한다.
        if (!hit) HitTestTriangle(t1, t0);

        // 삼각형의 외곽선을 그린다.
        t0.DrawSegments();
        t1.DrawSegments();
    }

    // 삼각형을 평면과 선분 역할로 구분하여 충돌 테스트를 한다.
    private bool HitTestTriangle(Triangle triangleForPlane, Triangle triangle)
    {
        bool hit = false;

        // 각각의 선분이 삼각형과 걸치는지 확인
        for (int i = 0; i < triangle.Segments.Length; i++)
        {
            Color segmentColor = Color.black;

            // 현재 선분과 삼각형의 평면이 충돌하는지 확인, 선분 길이 대비 충돌지점의 비율을 반환 받는다.
            float t = triangleForPlane.HitTestWithSegment(triangle.Vertices[i].position, triangle.Segments[i]);
            if (t >= 0f && t <= 1f) // 삼각형의 평면과 선분이 충돌했다.
            {
                // 삼각형의 평면과 선분의 히트 포인트(충돌 지점)
                Vector3 hitPoint = triangle.Vertices[i].position + triangle.Segments[i] * t;

                // 히트 포인트가 삼각형 안에 있는지 확인
                Vector3[] crossVectors = new Vector3[triangleForPlane.Segments.Length];
                for (int jj = 0; jj < triangleForPlane.Segments.Length; jj++)
                {
                    // 각 꼭지점에서 히트 포인트까지 벡터를 구하고 인접변과 외적한다.
                    Vector3 toHitPoint = hitPoint - (triangleForPlane.Vertices[jj].position + triangleForPlane.Segments[jj]);
                    crossVectors[jj] = Vector3.Cross(triangleForPlane.Segments[jj], toHitPoint);

                    // 외적 벡터 그리기
                    Gizmos.color = _crossVectorColors[i];
                    Gizmos.DrawLine(triangleForPlane.Vertices[jj].position, triangleForPlane.Vertices[jj].position + crossVectors[jj].normalized * 3f);
                }

                // 외적한 모든 벡터가 같은 방향이면 히트 포인트는 삼각형 안에 있다.
                // 같은 방향의 벡터끼리 내적하면 1~0(0~90도) 양수, 다른 방향의 벡터끼리 내적하면 0~-1(90~180도) 음수
                if (Vector3.Dot(crossVectors[0], crossVectors[1]) > 0 && Vector3.Dot(crossVectors[1], crossVectors[2]) > 0)
                {
                    hit = true;

                    segmentColor = Color.white; // 충돌했으므로 선분색을 변경한다.

                    Gizmos.color = _crossVectorColors[i]; // 충돌지점마다 색을 다르게 한다.
                    Gizmos.DrawWireSphere(hitPoint, 1f); // 충돌지점을 그린다.

                    for (int jj = 0; jj < triangleForPlane.Segments.Length; jj++)
                    {
                        Gizmos.DrawLine(triangleForPlane.Vertices[jj].position, hitPoint); // 꼭짓점과 충돌지점까지 선을 그린다.
                    }
                }
            }

            triangle.SegmentColors[i] = segmentColor;
        }

        return hit;
    }
}