Unity 디버깅 도구 사용법

로봇 시뮬레이션 프로젝트에서 발생할 수 있는 다양한 문제를 효과적으로 해결하기 위해서는 강력한 디버깅 도구의 활용이 필수적이다. Unity는 개발자가 오류를 식별하고 수정하며 성능을 최적화할 수 있도록 다양한 디버깅 도구를 제공한다. 이 절에서는 Unity의 주요 디버깅 도구와 그 사용법에 대해 상세히 살펴보겠다.

Unity Console 창

Unity의 Console 창은 디버깅의 핵심 도구 중 하나로, 오류 메시지, 경고, 일반 로그 등을 실시간으로 확인할 수 있다.

오류 메시지(Error Messages): 스크립트 오류나 예외가 발생하면 Console 창에 빨간색으로 표시된다. 오류 메시지를 클릭하면 관련 스크립트의 해당 줄로 즉시 이동할 수 있어 빠른 수정이 가능한다.
경고 메시지(Warnings): 잠재적인 문제를 경고하는 메시지로, 노란색으로 표시된다. 예를 들어, 사용되지 않는 변수나 비효율적인 코드 사용 시 경고가 나타날 수 있다.
일반 로그(Logs): Debug.Log를 통해 출력되는 정보로, 흰색으로 표시된다. 코드의 흐름을 추적하거나 변수의 값을 확인하는 데 유용하다.

Console 창 사용 예제

using UnityEngine;

public class DebugExample : MonoBehaviour
{
    void Start()
    {
        Debug.Log("시뮬레이션이 시작되었다.");
        Debug.LogWarning("이것은 경고 메시지이다.");
        Debug.LogError("이것은 오류 메시지이다.");
    }
}

위의 스크립트를 실행하면 Console 창에 각각의 메시지가 다른 색상으로 표시된다. 이를 통해 개발자는 코드의 상태를 실시간으로 모니터링할 수 있다.

Debug.Log를 이용한 로그 출력

Debug.Log, Debug.LogWarning, Debug.LogError는 코드 실행 중에 정보를 출력하는 데 사용된다. 이를 통해 변수의 값, 함수의 호출 여부 등을 쉽게 추적할 수 있다.

변수 값 추적 예제

using UnityEngine;

public class VariableTracker : MonoBehaviour
{
    public float speed = 5.0f;

    void Update()
    {
        Debug.Log("현재 속도: " + speed);
        // 속도 변경 로직
    }
}

이 스크립트는 매 프레임마다 현재 속도를 Console 창에 출력하여, 속도가 예상대로 변경되고 있는지 확인할 수 있다.

브레이크포인트 설정 및 스크립트 디버깅

Unity는 Visual Studio와 같은 외부 IDE와의 연동을 통해 브레이크포인트를 설정하고, 코드 실행을 단계별로 추적할 수 있는 기능을 제공한다.

브레이크포인트 설정 방법

Visual Studio 연동: Unity 에디터에서 Edit > Preferences > External Tools로 이동하여 외부 스크립팅 IDE를 Visual Studio로 설정한다.
브레이크포인트 추가: Visual Studio에서 디버깅할 스크립트를 열고, 중단하고 싶은 줄의 왼쪽 여백을 클릭하여 브레이크포인트를 추가한다.
디버깅 시작: Unity 에디터에서 Attach to Unity 버튼을 클릭하여 디버거를 연결한다. 이후 게임을 실행하면 브레이크포인트에서 실행이 중단되며, 변수의 현재 상태를 확인하고 코드 흐름을 단계별로 분석할 수 있다.

디버깅 예제

using UnityEngine;

public class DebuggingExample : MonoBehaviour
{
    void Start()
    {
        int a = 10;
        int b = 20;
        int sum = a + b; // 여기에서 브레이크포인트 설정
        Debug.Log("합계: " + sum);
    }
}

브레이크포인트를 int sum = a + b; 줄에 설정하면, 해당 줄에서 코드 실행이 중단되어 a와 b의 현재 값을 확인할 수 있다.

Unity Profiler를 이용한 성능 분석

Profiler는 Unity의 성능을 분석하고 최적화할 수 있는 강력한 도구이다. CPU, GPU, 메모리 사용량 등을 실시간으로 모니터링할 수 있으며, 병목 현상을 식별하는 데 유용하다.

Profiler 창 열기

Window > Analysis > Profiler를 통해 Profiler 창을 열 수 있다. Profiler 창에서는 다양한 탭을 통해 상세한 성능 정보를 확인할 수 있다.

주요 Profiler 탭

CPU Usage: CPU의 사용량과 각 함수의 실행 시간을 분석할 수 있다.
GPU Usage: GPU의 성능을 모니터링하고, 그래픽 렌더링과 관련된 병목을 식별할 수 있다.
Memory: 메모리 사용량을 추적하여 메모리 누수나 과도한 메모리 사용을 방지할 수 있다.
Rendering: 렌더링 파이프라인의 각 단계를 분석하여 그래픽 성능을 최적화할 수 있다.

Profiler 사용 예제

using UnityEngine;

public class ProfilerExample : MonoBehaviour
{
    void Update()
    {
        // 무거운 연산 예제
        for(int i = 0; i < 1000000; i++)
        {
            // 연산
        }
    }
}

이 스크립트를 실행하고 Profiler의 CPU Usage 탭을 확인하면, Update 함수 내의 루프가 CPU 사용량에 미치는 영향을 상세히 분석할 수 있다. 이를 통해 성능 저하의 원인을 파악하고 최적화할 수 있다.

Gizmos를 이용한 시각적 디버깅

Gizmos는 에디터 내에서 오브젝트의 상태를 시각적으로 표시하는 도구로, 디버깅 시 유용하게 활용된다. 예를 들어, 로봇의 센서 범위나 경로를 시각적으로 표현할 수 있다.

Gizmos 사용 예제

using UnityEngine;

public class GizmoExample : MonoBehaviour
{
    public float detectionRadius = 5.0f;

    void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, detectionRadius);
    }
}

이 스크립트는 오브젝트의 위치를 중심으로 반경이 detectionRadius인 빨간색 와이어 구를 그려, 센서의 탐지 범위를 시각적으로 확인할 수 있게 한다.

Frame Debugger를 이용한 렌더링 과정 분석

Frame Debugger는 각 프레임의 렌더링 과정을 단계별로 분석할 수 있는 도구로, 그래픽 관련 문제를 디버깅하는 데 유용하다.

Frame Debugger 사용 방법

Frame Debugger 활성화: Window > Analysis > Frame Debugger를 통해 Frame Debugger 창을 엽니다.
디버깅할 프레임 선택: Enable 버튼을 클릭하여 디버깅을 시작하고, 분석할 프레임을 선택한다.
렌더링 단계 분석: Frame Debugger는 렌더링 파이프라인의 각 단계를 단계별로 표시하며, 각 단계에서 어떤 드로우 콜이 발생했는지 확인할 수 있다.

Frame Debugger 예제

Frame Debugger를 사용하여 특정 프레임에서 발생하는 드로우 콜을 분석하면, 불필요한 드로우 콜을 줄이거나 최적화할 수 있는 부분을 식별할 수 있다. 예를 들어, 동일한 메시지가 여러 번 드로우 콜되는 경우, 인스턴싱을 통해 최적화할 수 있다.

Memory Profiler를 이용한 메모리 사용 분석

Memory Profiler는 Unity 애플리케이션의 메모리 사용량을 상세히 분석할 수 있는 도구이다. 메모리 누수나 불필요한 메모리 사용을 발견하고 최적화하는 데 유용하다.

Memory Profiler 창 열기

Window > Analysis > Memory Profiler를 통해 Memory Profiler 창을 열 수 있다. 이 도구는 현재 애플리케이션의 메모리 상태를 스냅샷 형태로 캡처하여 분석할 수 있게 한다.

메모리 스냅샷 캡처

스냅샷 찍기: Memory Profiler 창에서 Take Snapshot 버튼을 클릭하여 현재 메모리 상태를 캡처한다.
스냅샷 비교: 여러 개의 스냅샷을 찍어 비교함으로써 메모리 사용량의 변화를 추적할 수 있다.
메모리 할당 분석: 스냅샷을 분석하여 어떤 객체가 메모리를 많이 사용하고 있는지, 불필요하게 메모리를 할당하고 있는지를 확인할 수 있다.

메모리 사용 예제

using UnityEngine;

public class MemoryExample : MonoBehaviour
{
    void Start()
    {
        // 큰 텍스처 로드
        Texture2D largeTexture = new Texture2D(4096, 4096);
        // 메모리 할당 확인을 위해 텍스처 생성
        for(int y = 0; y < largeTexture.height; y++)
        {
            for(int x = 0; x < largeTexture.width; x++)
            {
                largeTexture.SetPixel(x, y, Color.white);
            }
        }
        largeTexture.Apply();
    }
}

이 스크립트를 실행하고 Memory Profiler를 통해 메모리 사용량을 확인하면, largeTexture 객체가 상당한 양의 메모리를 할당하고 있음을 알 수 있다. 이를 통해 메모리 최적화가 필요한 부분을 식별할 수 있다.

Deep Profiling을 이용한 상세 성능 분석

Deep Profiling은 Unity Profiler의 고급 기능으로, 함수 호출과 메서드 내부의 세부적인 성능 데이터를 제공한다. 이를 통해 더욱 정밀한 성능 최적화가 가능한다.

Deep Profiling 활성화

Profiler 창 열기: Window > Analysis > Profiler에서 Profiler 창을 엽니다.
Deep Profiling 활성화: Profiler 창 상단의 Deep Profile 체크박스를 활성화한다. 이 설정을 통해 모든 함수 호출과 그 내부의 세부 데이터를 수집할 수 있다.

Deep Profiling 사용 예제

using UnityEngine;

public class DeepProfilerExample : MonoBehaviour
{
    void Start()
    {
        PerformHeavyComputation();
    }

    void PerformHeavyComputation()
    {
        for(int i = 0; i < 10000; i++)
        {
            // 복잡한 계산
            float value = Mathf.Sqrt(i) * Mathf.Sin(i);
        }
    }
}

Deep Profiling을 활성화한 상태에서 이 스크립트를 실행하면, PerformHeavyComputation 함수 내부의 각 계산 단계별로 세부적인 성능 데이터를 Profiler에서 확인할 수 있다. 이를 통해 특정 연산이 전체 성능에 미치는 영향을 정확히 분석할 수 있다.

Physics Debugging 도구

로봇 시뮬레이션에서는 물리 엔진과의 상호작용이 중요하다. Unity는 물리 엔진 디버깅을 위한 다양한 도구를 제공한다.

Physics Debugger 창 열기

Window > Analysis > Physics Debugger를 통해 Physics Debugger 창을 열 수 있다. 이 도구는 물리 엔진의 상태를 시각적으로 표시하여 충돌, 힘, 제약 조건 등을 분석할 수 있게 한다.

Physics Debugger 사용 예제

충돌체 시각화: Physics Debugger를 통해 모든 충돌체(Colliders)를 시각적으로 확인할 수 있다. 이를 통해 로봇의 충돌 범위를 정확히 파악하고, 예상치 못한 충돌을 발견할 수 있다.
힘 및 운동량 확인: 로봇에 작용하는 힘과 운동량을 실시간으로 모니터링하여 물리적 상호작용을 분석할 수 있다.
제약 조건 분석: 조인트(Joints)나 기타 물리적 제약 조건의 동작 상태를 점검하여 올바르게 설정되었는지 확인할 수 있다.

using UnityEngine;

public class PhysicsDebugExample : MonoBehaviour
{
    public Rigidbody rb;

    void Start()
    {
        // 힘을 가해 로봇을 움직임
        rb.AddForce(new Vector3(0, 10, 0), ForceMode.Impulse);
    }
}

이 스크립트를 실행하고 Physics Debugger를 활성화하면, Rigidbody에 가해진 힘과 그로 인한 운동을 시각적으로 확인할 수 있다. 이를 통해 물리 상호작용이 예상대로 작동하는지 검증할 수 있다.

애니메이션 디버깅 도구

로봇의 움직임이 자연스럽게 구현되었는지 확인하기 위해 애니메이션 디버깅 도구를 활용할 수 있다.

Animation Debugger 창 열기

Window > Animation > Animation Debugger를 통해 Animation Debugger 창을 열 수 있다. 이 도구는 애니메이션의 상태, 전환, 파라미터 등을 실시간으로 분석할 수 있게 한다.

Animation Debugger 사용 예제

애니메이션 상태 확인: 현재 재생 중인 애니메이션 상태를 확인하고, 올바른 애니메이션이 재생되고 있는지 점검할 수 있다.
애니메이션 전환 분석: 애니메이션 간 전환이 원활하게 이루어지는지, 불필요한 지연이나 끊김이 없는지 분석할 수 있다.
파라미터 모니터링: 애니메이션 파라미터의 값을 실시간으로 확인하여, 애니메이션 로직이 올바르게 작동하는지 검증할 수 있다.

using UnityEngine;

public class AnimationDebugExample : MonoBehaviour
{
    public Animator animator;

    void Update()
    {
        if(Input.GetKeyDown(KeyCode.Space))
        {
            animator.SetTrigger("Jump");
        }
    }
}

이 스크립트를 실행하고 Animation Debugger를 활성화하면, Jump 트리거가 활성화될 때 애니메이션 상태가 어떻게 변하는지 실시간으로 확인할 수 있다. 이를 통해 애니메이션 전환이 원활하게 이루어지는지 검증할 수 있다.

네트워크 디버깅 도구

멀티 로봇 시뮬레이션이나 원격 제어 로봇 시뮬레이션에서는 네트워크 통신이 중요한 역할을 한다. Unity는 네트워크 통신을 디버깅할 수 있는 도구도 제공한다.

Network Profiler 사용

Network Profiler 활성화: Window > Analysis > Profiler에서 Profiler 창을 열고, Network 탭을 선택한다.
네트워크 활동 모니터링: 네트워크를 통해 주고받는 데이터 패킷의 크기, 빈도, 지연 시간 등을 실시간으로 모니터링할 수 있다.

Network Debugging 예제

using UnityEngine;
using UnityEngine.Networking;

public class NetworkDebugExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(GetRequest("https://example.com/data"));
    }

    IEnumerator GetRequest(string uri)
    {
        UnityWebRequest webRequest = UnityWebRequest.Get(uri);
        yield return webRequest.SendWebRequest();

        if(webRequest.result == UnityWebRequest.Result.ConnectionError)
        {
            Debug.LogError("네트워크 오류: " + webRequest.error);
        }
        else
        {
            Debug.Log("응답: " + webRequest.downloadHandler.text);
        }
    }
}

이 스크립트를 실행하고 Network Profiler를 활성화하면, GetRequest 함수가 보내는 HTTP 요청과 응답의 세부 정보를 실시간으로 확인할 수 있다. 이를 통해 네트워크 통신의 효율성과 신뢰성을 검증할 수 있다.

커스텀 디버깅 도구 개발

특정 로봇 시뮬레이션 요구사항에 맞추어 커스텀 디버깅 도구를 개발하는 것도 유용하다. Unity는 확장성이 높아, 필요에 따라 자체적인 디버깅 도구를 구현할 수 있다.

커스텀 디버깅 UI

Unity의 UI 시스템을 활용하여 실시간으로 로봇의 상태를 표시하거나, 특정 이벤트를 모니터링하는 커스텀 디버깅 패널을 만들 수 있다.

using UnityEngine;
using UnityEngine.UI;

public class CustomDebugUI : MonoBehaviour
{
    public Text debugText;
    private float runtime;

    void Update()
    {
        runtime += Time.deltaTime;
        debugText.text = "Runtime: " + runtime.ToString("F2") + " seconds";
    }
}

이 스크립트는 화면에 실시간으로 게임의 런타임을 표시하는 간단한 디버깅 UI를 구현한다. 이를 통해 시뮬레이션의 진행 상태를 직관적으로 파악할 수 있다.

로그 파일 작성

실행 중 발생하는 로그를 파일로 저장하여, 후속 분석을 위해 활용할 수 있다.

using UnityEngine;
using System.IO;

public class FileLogger : MonoBehaviour
{
    private StreamWriter writer;

    void Start()
    {
        writer = new StreamWriter("log.txt", true);
        writer.WriteLine("시뮬레이션 시작: " + System.DateTime.Now);
    }

    void Update()
    {
        writer.WriteLine("현재 시간: " + Time.time);
    }

    void OnApplicationQuit()
    {
        writer.WriteLine("시뮬레이션 종료: " + System.DateTime.Now);
        writer.Close();
    }
}

이 스크립트는 시뮬레이션 시작과 종료 시점, 그리고 매 프레임마다 현재 시간을 log.txt 파일에 기록한다. 이를 통해 시뮬레이션의 동작 기록을 남기고, 이후 분석에 활용할 수 있다.