서리 개인 개발 블로그

※ 로그 출력, 디버깅 포스팅은 아래 링크 확인하기

로그를 호출한 함수 및 라인넘버 출력하는 매크로

//프로젝트 헤더에 작성하면 된다.
#define CALLINFO (FString(__FUNCTION__) + TEXT("(") + FString::FromInt(__LINE__) + TEXT(")"))

• __FUNCTION__ : 함수명
• __LINE__ : 라인 넘버

//로그를 출력할 라인에 다음과 같이 입력.
UE_LOG(LogTemp, Warning, TEXT("%s"), *CALLINFO);

• CALLINFO를 적용하려면 해당 매크로를 가진 헤더를 포함시켜줘야한다.

결과

- 로그를 입력한 함수와 라인넘버가 Output Log창에 표시된다.

UE_LOG를 매크로로 정의하기

//헤더 파일에 입력
#define CALLINFO (FString(__FUNCTION__) + TEXT("(") + FString::FromInt(__LINE__) + TEXT(")"))
#define PRINT_CALLINFO() UE_LOG(LogTemp, Warning, TEXT("%s"), *CALLINFO)

//로그를 출력할 라인에 다음과 같이 입력
PRINT_CALLINFO();

인수를 여러개 넘겨받는 로그 매크로 정의하기

//헤더 파일에 입력
#define CALLINFO (FString(__FUNCTION__) + TEXT("(") + FString::FromInt(__LINE__) + TEXT(")"))
#define PRINT_LOG(fmt, ...) UE_LOG(LogTemp, Warning, TEXT("%s %s"), *CALLINFO, *FString::Printf(fmt, ##__VA_ARGS__))

//로그를 출력할 라인에 다음과 같이 입력
PRINT_LOG(TEXT("LogTest : %s"), TEXT("Log project"));

• ... : 가변 인수

결과

카테고리 매크로 정의하기

//헤더 파일에 입력
DECLARE_LOG_CATEGORY_EXTERN(TESTLOG, Log, All);

#define CALLINFO (FString(__FUNCTION__) + TEXT("(") + FString::FromInt(__LINE__) + TEXT(")"))
#define PRINT_CALLINFO() UE_LOG(TESTLOG, Warning, TEXT("%s"), *CALLINFO)

//CPP 파일에 입력
DEFINE_LOG_CATEGORY(TESTLOG);

결과

• 카테고리가 선언한 문자로 출력된다.

Mixamo 애니메이션이 필요해서 UE5 모델로 리타게팅을 시도해봤지만, 비정상적으로 리타게팅이 되었다. 본 이름도 맞춰보고 이것저것 시도해본것중 제일 정상적으로 결과물이 나온 정보를 찾봤다.

Mixamo 사이트에서 애니메이션 다운받는 방법

1. 다음 링크에서 모델을 다운받는다 - 다운받기

 ※ 혹시라도 해당 링크가 들어가지지 않는다면 포스팅 하단 영상 링크에서 설명란 찾아볼것

2. 압축을 풀어주고 Mixamo 사이트에서 'UPLOAD CHARACTER'를 눌러 다운받은 모델을 올려준다.

3. 원하는 애니메이션을 선택해 다운받아준다.

언리얼 애니메이션 설정

1. 앞에서 다운받은 모델을 먼저 임포트한다. (스켈레톤은 없음으로 설정하고 임포트)

2. 모델이 있는 폴더에 Mixamo에서 다운받은 애니메이션 파일을 다음과 같은 설정으로 임포트해준다.

 ※ 스켈레톤을 앞서 임포트한 'Unreal_Skeleton'으로 설정.

 ※ 메시 임포트는 꺼주고 '모두 임포트' 해준다. (혹시 메시를 추가로 임포트할 경우, 애니메이션 임포트를 체크했는지 확인할 것.)

3. Characters\Mannequin_UE4\Rigs 폴더에서 IK_UE4_Mannequin을 복사해 가져온다.

 ※ 가져온 후, 헷갈림을 방지하기 위해 파일명 변경할 것. (필자의 경우 IK_Mixamo_Mannequin으로 변경)

4. 가져온 Rig 파일을 AssetActions - Bulk Edit via Property Matrix를 눌러 창을 열어준다.

5. Imported Skeleton에서 스켈레톤을 언리얼 스켈레톤으로 설정한다.

6. 우클릭 - 애니메이션 - IK 리타게터 생성 후, Rig 파일을 'IK_Mixamo_Mannequin'으로 설정.

7. 만든 IK 리타게터를 열어서 타겟 IK 릭 에셋을 'IK_UE4_Mannequin'으로 설정한 뒤 저장해준다.

8. Mixamo 애니메이션 파일을 우클릭 - 애니메이션 에셋 리타깃 - 애니메이션 에셋 복제 및 리타깃을 클릭해 창을 열어준 뒤, Target IK Rig Asset을 IK_UE4_Mannequinn으로 선택해준 뒤 리타겟 클릭.

9. 생성된 UE4_Mannequin 애니메이션을 다시 UE5_Mannequin 애니메이션으로 리타게팅 해주면 된다.

※ 참고한 유튜브 영상

NavMesh를 이용해 기능을 구현하던 중, NavMesh가 씬에는 존재하지만 메쉬 데이터가 생성되지 않아서 네비게이션 기능이 동작하지 않음. 찾아본 결과, 프로젝트 세팅에 문제가 있었던걸로 확인.

해결 방법

- Project settings - Navigation mesh - Is world partition enabled를 체크 해제해주면 된다.

풀이 코드

using System;
using System.Collections.Generic;

public class Solution {
    private HashSet<int> m_visited = new HashSet<int>();

    public int solution(int n, int[,] computers) {
        int answer = 0;
        for(int i = 0; i < n; i++)
        {
            if(!m_visited.Contains(i))
            {
                answer++;
                DFS(computers, i);
            }
        }
        return answer;
    }

    private void DFS(int[,] computers, int currentIndex)
    {
        m_visited.Add(currentIndex);
        for(int i = 0; i < computers.GetLength(0); i++)
        {
            if(m_visited.Contains(i) || currentIndex == i ||
              computers[currentIndex, i] == 0)
            {
                continue;
            }

            DFS(computers, i);
        }
    }
}

• 재귀함수를 이용하여 DFS를 구현하였다. (Stack 및 반복문을 이용하는 방법도 있지만, 코드가 복잡하게 보일까봐 재귀함수로 작성)

기타

- 그래프를 평소에 다루어 보지 않아서 한참을 헤맸다. (통과는 됐지만 이게 진짜 문제에서 요구하는게 맞는지 헷갈림)

풀이 코드

using System;
using System.Collections.Generic;

public class Solution {
    public int[] solution(string[] operations) {
        Heap heap = new Heap();
        for(int i = 0; i < operations.Length; i++)
        {
            string[] split = operations[i].Split(" ");
            if(split[0] == "I")
            {
                heap.Add(Int32.Parse(split[1]));
            }
            else
            {
                if(split[1] == "1")
                {
                    heap.RemoveMax();
                }
                else
                {
                    heap.RemoveMin();
                }
            }
        }
        int[] answer = heap.GetAnswer();
        return answer;
    }
}

public class Heap
{
    private List<int> m_minHeap = new List<int>();
    private List<int> m_maxHeap = new List<int>();

    public void Add(int n)
    {
        m_minHeap.Add(n);
        SortUp(m_minHeap, CompareMin);
        m_maxHeap.Add(n);
        SortUp(m_maxHeap, CompareMax);
    }

    public void RemoveMin()
    {
        if(m_minHeap.Count <= 0 || m_maxHeap.Count <= 0)
        {
            return;
        }

        m_minHeap[0] = m_minHeap[m_minHeap.Count - 1];
        m_minHeap.RemoveAt(m_minHeap.Count - 1);
        SortDown(m_minHeap, CompareMin);

        m_maxHeap.RemoveAt(m_maxHeap.Count - 1);
    }

    public void RemoveMax()
    {
        if(m_minHeap.Count <= 0 || m_maxHeap.Count <= 0)
        {
            return;
        }

        m_maxHeap[0] = m_maxHeap[m_maxHeap.Count - 1];
        m_maxHeap.RemoveAt(m_maxHeap.Count - 1);
        SortDown(m_maxHeap, CompareMax);

        m_minHeap.RemoveAt(m_minHeap.Count - 1);
    }

    public int[] GetAnswer()
    {
        int[] answer = new int[] { 0, 0 };
        if(m_maxHeap.Count > 0 && m_minHeap.Count > 0)
        {
            answer[0] = m_maxHeap[0];
            answer[1] = m_minHeap[0];
        }

        return answer;
    }

    private void SortDown(List<int> list, Func<int, int, int> compare)
    {
        int currentIndex = 0;
        while(true)
        {
            int leftIndex = currentIndex * 2 + 1;
            int rightIndex = currentIndex * 2 + 2;
            int swapIndex = currentIndex;

            if(leftIndex < list.Count)
            {
                swapIndex = leftIndex;

                if(rightIndex < list.Count)
                {
                    if(compare.Invoke(list[leftIndex], list[rightIndex]) < 0)
                    {
                        swapIndex = rightIndex;
                    }
                }

                if(compare.Invoke(list[currentIndex], list[swapIndex]) < 0)
                {
                    Swap(list, currentIndex, swapIndex);
                    currentIndex = swapIndex;
                }
                else
                {
                    return;
                }
            }
            else
            {
                return;
            }
        }
    }

    private void SortUp(List<int> list, Func<int, int, int> compare)
    {
        int currentIndex = list.Count - 1;
        int parentIndex = currentIndex / 2;
        while(true)
        {
            if(compare.Invoke(list[currentIndex], list[parentIndex]) > 0)
            {
                Swap(list, currentIndex, parentIndex);
                currentIndex = parentIndex;
                parentIndex = currentIndex / 2;
            }
            else
            {
                break;
            }
        }
    }

    private void Swap(List<int> list, int indexA, int indexB)
    {
        int tmp = list[indexA];
        list[indexA] = list[indexB];
        list[indexB] = tmp;
    }

    private int CompareMax(int a, int b)
    {
        return a.CompareTo(b);
    }

    private int CompareMin(int a, int b)
    {
        return -CompareMax(a, b);
    }
}

• 최소값을 루트에 갖는 List와 최대값을 루트에 갖는 List 2개를 만들어주고, 값이 들어가거나 빠질때마다 SortUp, SortDown으로 리스트를 갱신해준다.
• 최종 결과값은 최소 List와 최대 List의 루트값을 출력해주면 된다.

기타

- 문제 카테고리가 힙으로 분류되어있어서 힙을 구현해서 사용했다. (다른사람 풀이를 보니 Linq를 사용해서 짧게 작성했던데, 카테고리 생각하면 Linq사용하는게 정답같아보이지는 않는다.)

- 힙에 대한 설명은 아래 포스팅 참조