Mesh Slicing

private void CastFrontRay()
{
    Ray frontRay = new Ray(_katanaRay.position, _katanaRay.forward);
    RaycastHit frontHit;

    if (Physics.Raycast(frontRay, out frontHit, _katanaRayLength, _sliceTargetLayer))
    {
        HasFrontHit = true;
        ProcessHit(frontHit, FrontHitDic, FrontHitPoints);
    }
}

private void CastBackRay()
{
    Vector3 backRayStartPoint = _katanaRay.position + _katanaRay.forward * _katanaRayLength;
    Vector3 backDirection = -_katanaRay.forward;
    Ray backRay = new Ray(backRayStartPoint, backDirection);
    RaycastHit backHit;

    if (Physics.Raycast(backRay, out backHit, _katanaRayLength, _sliceTargetLayer))
    {
        HasBackHit = true;
        ProcessHit(backHit, BackHitDic, BackHitPoints);
    }
}

private void ProcessHit(RaycastHit hit, Dictionary<int, Vector3> hitDataDict, 
                       List<Vector3> hitPointsList)
{
    GameObject hitObject = hit.collider.gameObject;
    int triIndex = hit.triangleIndex; // Triangle 인덱스 추출

    if (!HitTriangles.Contains(triIndex)) 
        HitTriangles.Add(triIndex);

    if (!hitDataDict.ContainsKey(triIndex))
    {
        hitDataDict[triIndex] = hit.point;
        hitPointsList.Add(hit.point);
    }
}

// 교차된 Triangle들을 DFS로 그룹화
void GroupTriangles(int startTriangle, HashSet<int> visited, List<int> group)
{
    // 현재 Triangle 방문 처리
    visited.Add(startTriangle);
    group.Add(startTriangle);
    
    // 인접한 Triangle들 탐색
    foreach (int neighbor in GetNeighbors(startTriangle))
    {
        // 마킹되었고 아직 방문하지 않은 Triangle만 재귀 탐색
        if (IsMarked(neighbor) && !visited.Contains(neighbor))
        {
            GroupTriangles(neighbor, visited, group);
        }
    }
}

// 모든 그룹 생성
List<List<int>> CreateAllGroups()
{
    HashSet<int> visited = new HashSet<int>();
    List<List<int>> allGroups = new List<List<int>>();
    
    foreach (int triangle in markedTriangles)
    {
        if (!visited.Contains(triangle))
        {
            List<int> group = new List<int>();
            GroupTriangles(triangle, visited, group);
            allGroups.Add(group);
        }
    }
    
    return allGroups;
}

// World Space Ray를 Local Space로 변환
public Ray WorldToLocalRay(Ray worldRay, Transform meshTransform)
{
    // Ray 원점을 Local Space로 변환
    Vector3 localOrigin = meshTransform.InverseTransformPoint(worldRay.origin);
    
    // Ray 방향을 Local Space로 변환 (크기 무시)
    Vector3 localDirection = meshTransform.InverseTransformDirection(worldRay.direction);
    
    return new Ray(localOrigin, localDirection.normalized);
}