유니티 개발자를 위한 언리얼 엔진

이 페이지에서는 유니티에 익숙한 사용자를 위한 언리얼 엔진(UE) 개요를 설명합니다. 유니티에 대한 지식이 있고, 학습한 내용을 언리얼 엔진 작업에 활용하는 방법을 알고 싶다면 아래 섹션이 시작하는 데 도움이 될 것입니다.

언리얼 에디터

언리얼 에디터 는 언리얼 엔진 프로젝트를 작업하는 곳입니다. 아래 스크린샷은 유니티와 언리얼 에디터를 나란히 보여줍니다. 영역별로 다른 컬러를 사용하여 공통 기능을 표시했습니다. 각 블록의 라벨은 해당하는 언리얼 엔진 용어를 보여줍니다.

언리얼 에디터의 레이아웃은 완전히 커스터마이징할 수 있습니다. 탭을 드래그 앤 드롭하고, 메인 창에 도킹하며, 컬러 체계를 바꿀 수 있습니다.

시각적으로 비교한 유니티와 언리얼 엔진 5의 주요 UI 요소. 이미지를 클릭하면 최대 크기로 볼 수 있습니다.

에셋 편집하기

유니티에서는 Inspector 탭을 사용하여 프로젝트의 선택된 에셋을 편집합니다. 언리얼 에디터에서는 디테일(Details) 패널에 선택된 오브젝트의 프로퍼티가 노출됩니다. 복잡한 에셋 편집은 별도의 창에서 이루어집니다. 이 창은 메인 UE 창에 도킹할 수도 있고, 두 번째 모니터 등 데스크톱의 다른 영역으로 드래그할 수도 있습니다.

언리얼 에디터의 탭으로 정리된 에디터. 레벨 에디터(Level Editor) 는 백그라운드에 있고, 머티리얼 에디터(Material Editor) 는 현재 활성화되어 있습니다.

간단 용어집

아래 표의 왼쪽은 유니티에서 자주 쓰이는 용어, 오른쪽은 상응하는(또는 대략적으로 비슷한) 언리얼 엔진 용어입니다. 언리얼 엔진 열의 용어에 있는 링크를 클릭하면 상세 정보를 확인할 수 있습니다.

프로젝트와 파일

언리얼 엔진 프로젝트의 공통 파일 및 디렉터리는 무엇인가요?

유니티 프로젝트와 마찬가지로 언리얼 프로젝트에는 별도의 디렉터리와 .uprojectfile 확장자를 가진 자체 프로젝트 파일이 있습니다. .uproject 파일을 더블클릭 하면 게임을 언리얼 에디터에 로드할 수 있으며, 우클릭 으로 추가 옵션을 확인할 수 있습니다.

프로젝트 폴더에는 게임의 콘텐츠와 소스는 물론 다양한 환경설정 파일과 바이너리가 들어있는 서브폴더가 들어있습니다. 가장 중요한 서브폴더는 프로젝트의 모든 에셋이 포함된 Content 폴더와 프로젝트의 환경설정 파일( .ini )이 저장된 Source 폴더입니다.

에셋은 어디에 저장하나요?

언리얼 엔진에는 프로젝트마다 Content 폴더가 있습니다. 유니티 프로젝트의 Assets 폴더처럼 이 폴더에는 게임 에셋이 저장됩니다.

언리얼 엔진 프로젝트에 C++ 클래스가 포함되어 있는 경우 디스크에 있는 프로젝트의 Source 폴더에 저장됩니다.

에셋을 게임에 임포트하려면 콘텐츠 브라우저를 통해 파일을 프로젝트의 Content 디렉터리에 드롭하세요.

어떤 파일 포맷이 지원되나요?

언리얼 엔진 5는 아래와 같이 가장 자주 쓰이는 파일 유형을 지원합니다.

특수 플러그인을 사용하면 다음과 같이 다른 유형의 콘텐츠도 임포트할 수 있습니다.

씬은 어떻게 저장되나요?

유니티에서는 씬에 게임 오브젝트를 배치하고 씬 에셋 파일로 저장합니다. 언리얼 엔진에는 유니티의 씬과 비슷한 맵 파일 이 있습니다. 맵 파일에는 레벨 과 그 안의 오브젝트에 대한 정보가 저장되며, 라이팅 데이터와 특정 레벨 전용 세팅도 포함됩니다.

프로젝트 세팅은 어떻게 변경하나요?

언리얼 에디터의 메인 메뉴에서 편집(Edit) > 프로젝트 세팅(Project Settings) 으로 이동합니다.

유니티의 프로젝트 세팅과 마찬가지로 언리얼의 프로젝트 세팅은 다음과 같은 역할을 수행합니다.

• 프로젝트 이름, 아이콘 등 프로젝트와 관련된 정보 제어

• 게임 입력 바인딩 환경설정

• 프로젝트 실행 시 엔진 작동 방식 정의

• 그 외

유니티에는 '플레이어 세팅(Player Settings)'이라는 설정도 있습니다. 언리얼 엔진에서는 플랫폼 세팅(Platform Settings) 에 해당하며, 프로젝트 세팅 창의 플랫폼 섹션에서 환경설정할 수 있습니다.

소스 파일은 어디로 가나요?

유니티에서는 주로 Assets 폴더에 C# 소스 파일을 넣습니다. 언리얼 엔진에서는 생성하는 언리얼 엔진 프로젝트의 유형에 따라 다른 위치에 소스 파일이 저장됩니다.

• C++ 프로젝트 에는 언리얼 프로젝트 디렉터리에 Source 폴더가 있습니다. Source 폴더에는 C++ 소스( .cpp ) 및 헤더( .h ) 파일, 몇몇 빌드 스크립트( Build.cs, Target.cs )를 비롯해 다양한 파일이 저장됩니다.

• 블루프린트 프로젝트 에는 Source 폴더가 없습니다. 블루프린트는 언리얼 프로젝트의 Content 폴더 어디에든 저장할 수 있습니다.

콘텐츠 브라우저에서 바로 C++ 클래스를 찾아 그 아이콘을 더블클릭하면 Visual Studio(Windows)나 Xcode(macOS)에서 열 수 있습니다.

게임 오브젝트에서 액터로

게임 오브젝트는 어디에 있나요?

유니티에서 게임 오브젝트는 월드에 배치할 수 있는 '사물'을 말합니다. 언리얼 엔진에서는 액터(Actor)가 여기에 해당합니다. 언리얼 에디터에서는 아래와 같이 메인 툴바 의 생성(Create) 메뉴에서 뷰포트로 새 빈 액터를 드래그하면 됩니다.

빈 액터로도 게임을 만들 수 있지만, 언리얼 엔진에는 내장 기능이 포함된 특수한 유형의 액터도 있습니다. 예를 들어, 폰(Pawn) 은 플레이어나 AI가 컨트롤할 수 있는 액터에 사용되고, 캐릭터(Character) 는 복잡한 로코모션 및 상호작용이 필요한 컨트롤 가능 플레이어 캐릭터에 사용됩니다. 이처럼 특수한 유형의 액터도 빈 액터처럼 뷰포트에 드롭한 다음 프로퍼티나 컴포넌트를 추가 또는 수정할 수 있습니다.

언리얼 엔진의 액터는 유니티의 게임 오브젝트와 약간 다릅니다. 유니티의 게임 오브젝트는 C# 클래스로, 바로 확장할 수 없습니다. 언리얼 엔진의 액터는 C++ 클래스로, 상속을 통해 확장 및 커스터마이징이 가능합니다. 상속에 대해서는 이 페이지 아래에서 더 자세히 알아봅니다.

컴포넌트는 어디에 있나요?

유니티에서는 컴포넌트로 게임 오브젝트에 기능을 추가합니다. 언리얼 엔진에서는 액터에 컴포넌트를 추가합니다. 레벨에 빈 액터를 드롭한 다음 액터를 선택하고, 디테일 패널의 컴포넌트 추가(Add Component) 버튼을 클릭한 뒤 추가할 컴포넌트를 선택합니다.

아래 동영상에서는 빈 액터를 드롭한 다음 베이스에 메시 컴포넌트를 추가하고, 라이트 소스와 파티클 시스템으로 화염을 만들어 횃불을 생성합니다.

유니티의 게임 오브젝트는 컴포넌트가 일반 목록으로 저장되지만, 언리얼 엔진의 액터에는 서로 어태치된 컴포넌트 계층구조(Hierarchy) 가 존재합니다. 위 예제에서도 스태틱 메시에 라이트와 파티클이 어태치되어 있는 것을 확인할 수 있습니다. 여기서 중요한 내용을 알 수 있는데, 이는 이 페이지의 복합 오브젝트(Compound Objects) 섹션에서 다루겠습니다.

유니티의 프리팹에서 언리얼 엔진의 블루프린트 클래스로

유니티에서는 컴포넌트로 게임 오브젝트 세트를 만든 다음, 거기서 프리팹을 생성합니다. 그런 다음 프리팹 인스턴스를 월드에 배치하거나 런타임에서 인스턴스화합니다.

언리얼 엔진에도 블루프린트 클래스를 바탕으로 한 동일한 워크플로가 있습니다.

1. 컴포넌트로 액터를 만듭니다.

2. 액터의 디테일 패널에서 블루프린트 > 스크립트 추가(Add Script) 를 클릭해 블루프린트를 추가합니다.

3. 새 블루프린트 클래스를 저장할 위치를 선택합니다.

4. 블루프린트 생성(Create Blueprint) 을 클릭합니다.

완료되었습니다!

새로운 블루프린트 클래스는 콘텐츠 브라우저 에서 찾을 수 있습니다. 블루프린트 클래스는 더블클릭 해서 바로 편집할 수도 있고, 오픈 레벨로 드래그해서 게임 월드에 배치할 수도 있습니다.

스크립트 컴포넌트와 MonoBehaviour는 어디에 있나요?

유니티에서는 게임 오브젝트에 드롭하여 C# 스크립팅을 추가할 수 있는 스크립트 컴포넌트가 있습니다. 이 컴포넌트의 역할을 정의하기 위해서는 MonoBehaviour를 상속하는 클래스를 생성합니다.

언리얼 엔진도 같은 방식으로 작동합니다. 블루프린트나 C++를 사용하여 새로운 컴포넌트 클래스를 만들고 이를 액터에 추가할 수 있습니다. 아래와 같은 두 가지 방법 중 하나를 사용하면 블루프린트를 액터에 추가하는 것처럼 액터에 컴포넌트를 추가할 수 있습니다.

• 액터의 디테일 패널.

• 액터 편집(Edit Actor) 창.

액터에 새 컴포넌트를 추가하는 방법은 아래와 같습니다.

1. 액터의 디테일 패널이나 액터 편집 창에서 컴포넌트 추가 를 클릭합니다.

2. 액터에 추가할 컴포넌트를 선택합니다. 새 컴포넌트를 생성할 수도 있고, 사전 정의된 라이트, 오디오, 파티클 시스템 등의 컴포넌트 목록에서 하나를 선택할 수도 있습니다.

   

유니티에서는 새로운 MonoBehaviour를 만들 때 Start() 함수와 Update() 함수가 있는 스켈레톤 클래스 파일이 주어집니다.

언리얼 엔진에서도 새 컴포넌트에 비슷한 함수가 있습니다.

• InitializeComponent() - 유니티의 Start()` 함수와 같은 역할을 합니다.
• TickComponent() - 유니티의 Update() 함수와 같은 역할을 합니다.

블루프린트 컴포넌트에서는 이러한 함수가 시각적 노드로 표시됩니다.

스크립팅 가능 액터 블루프린트 클래스

새로운 액터 블루프린트 클래스는 자체 블루프린트 비주얼 스크립팅을 가질 수 있습니다. 따라서 개별 컴포넌트가 아닌 전체 오브젝트에 로직을 추가할 수 있습니다. 아래에서 설명하는 상속 개념과 함께 사용하면 한층 유연하게 게임을 디자인할 수 있습니다.

언리얼 엔진은 블루프린트 클래스를 통해 비주얼 스크립팅을 지원할 뿐 아니라, 코드로 구현되는 C++ 클래스도 지원합니다. 다음은 유니티와 언리얼 엔진 코드를 나란히 비교한 것입니다. 그 아래에서는 같은 역할을 하는 언리얼 엔진 블루프린트를 확인할 수 있습니다.

		using UnityEngine;
		using System.Collections;

		public class MyComponent : MonoBehaviour
		{
			int Count;

			// 초기화에 사용.
			void Start ()
			{
				Count = 0;
			}

			// 업데이트는 프레임마다 호출.
			void Update ()
			{

				Count = Count + 1;
				Debug.Log(Count);
			}
		}
Copy full snippet

		#pragma once
		#include "GameFramework/Actor.h"
		#include "MyActor.generated.h"

		UCLASS()
		class AMyActor : public AActor
		{
			GENERATED_BODY()
			int Count;

			// 이 액터 프로퍼티의 디폴트값 설정.
			AMyActor()
			{
				// Tick() 호출 허용
				PrimaryActorTick.bCanEverTick = true;
			}

			// 게임 시작 시 또는 스폰 시 호출.
			void BeginPlay()
			{
				Super::BeginPlay();
				Count = 0;
			}

			// 모든 프레임에서 호출됩니다.
			void Tick(float DeltaSeconds)
			{
				Super::Tick(DeltaSeconds);
				Count = Count + 1;
				GLog->Log(FString::FromInt(Count));
			}
		};
Copy full snippet

블루프린트

블루프린트 클래스는 확장 가능

유니티의 프리팹처럼 언리얼 엔진에서도 블루프린트 클래스를 인스턴스화할 수 있습니다.

언리얼 엔진에서는 블루프린트 클래스를 새로 만들고, 기존 블루프린트 클래스를 확장하여 새로운 프로퍼티, 컴포넌트, 비주얼 스크립팅 기능을 추가할 수 있습니다.

예를 들어, 사람을 쫓는 등 기본적인 몬스터 기능을 구현하는 'Monster'라는 이름의 블루프린트 클래스를 만들 수 있습니다. 이제 다른 블루프린트 클래스를 생성해 이 블루프린트 클래스를 확장할 수 있습니다. 불을 뿜는 능력이 추가된 몬스터 'Dragon', 밤에만 출몰하는 몬스터 'Grue', 그 외 8개의 클래스를 만들어 다양한 종류의 몬스터를 만듭니다. 이러한 Monster 서브클래스는 Monster의 기본 기능을 상속하며, 각자 새로운 기능과 능력도 가지고 있습니다.

유니티에서 이를 구현하려면 Dragon, Grue 등 각기 다른 게임 오브젝트 프리팹을 여러 개 생성해야 합니다. 그런데 여기서 모든 몬스터에 새로운 기능을 추가하고 싶습니다. 예를 들어, 새로운 'Speak' 컴포넌트를 사용하여 말하는 능력을 추가하려고 합니다. 유니티에서는 새로운 기능을 10개의 프리팹에 모두 복사 및 붙여넣기해야 합니다.

언리얼 엔진에서는 그냥 Monster 블루프린트 클래스를 편집하여 대화 능력을 추가해 주기만 하면 됩니다. 간단합니다! Dragon, Grue, 나머지 8개의 Monster 서브클래스 모두 자동으로 새로운 대화 기능을 상속하므로 그 외에 다른 작업이 필요하지 않습니다.

이 섹션의 모든 내용은 C++ 클래스와 액터 및 컴포넌트에도 적용됩니다. 이 시스템은 확장 가능한 기능의 대규모 개발을 돕기 위해 만들어진 것으로, 개발자 수십 명 또는 수백 명 규모의 다양한 프로젝트에 사용할 수 있습니다.

블루프린트 스크립팅, C++, 또는 둘 다 사용하기

블루프린트 비주얼 스크립팅은 간단한 게임 내 로직이나 액션 시퀀스에 이상적입니다. 게임 내 오브젝트를 시각적인 방식으로 쉽게 접근하고 제어할 수 있어 디자이너, 아티스트, 비주얼 지향형 프로그래머에게 뛰어난 시스템입니다. 블루프린트만 사용해도 소규모 독립형 게임과 그 밖의 인터랙티브 경험을 만들 수 있습니다.

C++ 프로그래밍은 게임플레이 시스템, 복잡한 AI, 새로운 엔진 기능을 제작하는 등 대규모 작업에 사용됩니다. C++ 경험이 이미 있으신 분은 문서를 참조하셔서 언리얼 엔진에서의 C++ 프로그래밍에 관해 더 알아보세요.

대부분 프로젝트는 블루프린트와 C++를 같이 사용합니다. 많은 개발자는 프로토타입 제작과 반복작업이 쉬운 블루프린트를 사용하여 게임 기능 프로토타입을 제작하고, 나중에 퍼포먼스와 엔지니어링상의 이유로 일부 또는 전부를 C++로 옮깁니다.

블루프린트 클래스는 C++ 클래스를 확장 가능

언리얼 엔진 게임 개발은 대부분 C++로 신기능을 구현하는 프로그래머와 이를 블루프린트로 테스트하고 직접 피드백을 제공하는 디자이너 및 아티스트 사이의 상호작용을 통해 이루어집니다. 아래 예시는 시스템 프로그래밍에는 C++ 클래스를, 작동 방식과 외형에는 블루프린트 클래스를 함께 사용하여 UE 기반 슈팅 게임의 픽업 기능을 구현하는 과정을 나타낸 것입니다.

트랜스폼 컴포넌트

유니티에는 각 게임 오브젝트마다 트랜스폼 컴포넌트가 있어 게임 오브젝트의 월드 내 위치, 회전, 스케일을 정해줍니다.

언리얼 엔진에도 비슷하게 액터에 루트 컴포넌트(Root Component) 가 있습니다. 루트 컴포넌트는 씬 컴포넌트의 서브클래스가 될 수 있습니다. 씬 컴포넌트(Scene Component) 는 액터의 월드 내 위치, 회전, 스케일을 정해주며, 해당 씬 컴포넌트를 부모로 삼는 모든 컴포넌트에 적용됩니다. 위치가 있으면 매우 유용하기 때문에 여러분도 씬 컴포넌트에서 서브클래스로 만들어진 컴포넌트를 많이 사용하게 될 것입니다.

빈 액터를 배치해도 언리얼 엔진은 그 액터에 대해 디폴트 씬 루트를 생성하는데, 이는 일반적인 씬 컴포넌트입니다. 새로운 씬 컴포넌트를 드롭하면 디폴트 씬 루트가 대체됩니다.

복합 오브젝트

유니티에서는 아래와 같이 게임 오브젝트의 계층구조를 생성한 다음 그 트랜스폼을 같이 부모로 만들어 복합 오브젝트를 만듭니다.

언리얼 엔진에서는 아래와 같이 컴포넌트를 계층구조식으로 결합하여 복합 오브젝트를 만듭니다.

도표에서 볼 수 있듯이, 중첩된 계층구조는 씬 컴포넌트를 서로 어태치해서 생성할 수 있습니다. 씬 컴포넌트에 트랜스폼이 있기 때문입니다. 이는 유니티의 트랜스폼 부모 설정과 비슷합니다. 액터 컴포넌트(모든 컴포넌트의 베이스 클래스)는 액터 자신에게만 어태치할 수 있습니다.

모든 것을 컴포넌트로 만드나요?

여러분 선택에 달렸습니다! 보통 커스텀 컴포넌트 유형과 그 컴포넌트를 사용하는 액터 클래스를 조합해서 사용하게 될 것입니다. 앞에서 설명한 것처럼 언리얼 엔진에는 일정 수준의 능력을 보장하며 항상 특정 컴포넌트를 포함하는 여러 특수 유형 액터가 있습니다. 예를 들어 캐릭터 에는 항상 캐릭터 무브먼트 컴포넌트 가 포함됩니다.

흔히 사용되는 언리얼 엔진 액터는 아래와 같습니다.

• 폰 - 제어 가능한 게임 오브젝트(보통 플레이어의 아바타)를 나타내는 액터 유형입니다. 폰은 컨트롤러 소유를 통해 플레이어나 AI에 의해 움직입니다.

• 캐릭터 - 이족보행 아바타(인간처럼 두 발로 걷는 스켈레탈 구조를 가진 아바타)용으로 디자인된 특수한 폰입니다.

• 컨트롤러(Controller) - 폰을 빙의하여 제어합니다. 폰과 컨트롤러를 분리하면 플레이어와 동일한 인터페이스를 사용하여 폰을 조작할 수 있는 AI 컨트롤러를 작성할 수 있습니다.

• 플레이어 컨트롤러(Player Controller) - 게임패드, 터치, 마우스/키보드의 플레이어 입력을 받아 빙의 중인 폰 또는 캐릭터를 구동하기 위해 만들어진 보다 특수한 컨트롤러입니다.

그렇다면 모든 것이 액터인가요?

전부는 아닙니다. 액터 는 언리얼 엔진의 게임플레이에 사용되는 가장 흔한 클래스로, 월드에 스폰 될 수 있는 유일한 유형입니다. 즉, 레벨에 배치하는 모든 것은 액터가 됩니다.

또 한 가지 알아둬야 할 중요한 유형은 오브젝트 입니다. 오브젝트는 사실 액터 외 다수를 포함해서 모든 언리얼 클래스의 기본 클래스입니다. 액터보다 훨씬 낮은 레벨에서의 구성이지만, 리플렉션(Reflection) 이나 시리얼라이제이션(Serialization) 처럼 언리얼 클래스에서 기대하는 기능을 여전히 갖고 있습니다. 오브젝트는 액터 의 틀에 맞지 않는 새로운 유형을 정의할 필요가 있을 때 사용하는 매우 기본적인 클래스입니다. 예를 들어, 액터 컴포넌트 는 모든 컴포넌트의 베이스 클래스로 액터 가 아닌 오브젝트 에서 파생됩니다.

언리얼 엔진의 게임플레이 프레임워크는 무엇인가요?

새로운 유니티 프로젝트를 시작하면 게임 오브젝트와 컴포넌트 등을 직접 채워야 합니다. 언리얼 엔진에서도 액터와 컴포넌트로 게임을 만들 수 있습니다. 하지만 언리얼 엔진에는 게임플레이 프레임워크라는 레이어가 한 층 더 있습니다. 특정 프리미티브 클래스와 구체적인 작업 방식을 따르면 멀티플레이어 완벽 지원 등 구현이 어렵고 시간이 많이 소요되는 부가 기능이 게임에 자동으로 추가됩니다.

게임플레이 프레임워크를 사용하려면 폰, 캐릭터, 플레이어 컨트롤러 등 언리얼 엔진에 포함된 특수 내장 액터를 사용하고 커스터마이징하는 법을 배워야 합니다. 예를 들어, 멀티플레이어를 구현하고 싶다면 언리얼 엔진의 네트워킹과 리플리케이션 방식에 익숙해져야 합니다.

언리얼 엔진에서 코드 작성하기

C++ 프로그래머용

블루프린트 스크립팅의 경우 언리얼 에디터만 있으면 됩니다. 필요한 모든 기능이 내장되어 있기 때문입니다.

C++에서 코드를 작성하려면 Windows의 경우 Visual Studio를 다운로드하고, macOS의 경우 Xcode를 설치하세요. 언리얼 엔진에서 새 C++ 프로젝트를 처음 생성하거나 기존 프로젝트에 C++ 코드를 추가하면 엔진이 자동으로 Visual Studio 프로젝트 파일을 생성해 줍니다.

언리얼 엔진 프로젝트에서 Visual Studio에 액세스하는 방법은 두 가지입니다.

• 콘텐츠 브라우저 에서 C++ 클래스를 더블클릭 해 Visual Studio로 엽니다.

• 메인 메뉴에서 툴 > Visual Studio 열기(Open Visual Studio) 를 선택합니다. 이 옵션은 프로젝트에 하나 이상의 C++ 클래스가 있는 경우에만 표시됩니다.

언리얼 엔진과의 중요한 차이점 하나는 언리얼 엔진의 새 버전을 다운로드하거나 디스크의 소스 파일을 수동으로 변경했을 때를 비롯해 가끔씩 Visual Studio 프로젝트 파일을 수동으로 새로고침해야 한다는 것입니다. 수락하는 방법은 다음과 같은 두 가지가 있습니다.

• 언리얼 엔진의 메인 메뉴에서 툴 > Visual Studio 프로젝트 새로고침(Refresh Visual Studio Project) 을 클릭합니다.

• 프로젝트 디렉터리에 있는 .uproject 파일을 우클릭 한 다음 Visual Studio 프로젝트 파일 생성(Generate Visual Studio project files) 을 선택합니다.

이벤트 함수 작성하기(Start, Update 등)

MonoBehaviours로 작업해 본 적이 있다면 Start, Update, OnDestroy 같은 메서드에 익숙하실 것입니다. 아래는 유니티의 비헤이비어와 이에 해당하는 언리얼 엔진의 액터 및 컴포넌트를 비교한 것입니다.

유니티에는 아래와 같은 단순한 컴포넌트가 있을 수 있습니다.

	public class MyComponent : MonoBehaviour
	{
		void Start() {}
		void OnDestroy() {}
		void Update() {}
	}
Copy full snippet

언리얼 엔진에서는 새로운 컴포넌트 유형만 코딩하는 것이 아니라 액터 자체에 코드를 작성할 수 있습니다. 이 기능은 매우 자주 쓰이고 유용합니다.

유니티의 Start, OnDestroy, Update 함수와 마찬가지로, 언리얼 엔진의 액터에도 아래와 같은 비슷한 메서드 세트가 있습니다.

C++

	UCLASS()
	class AMyActor : public AActor
	{
		GENERATED_BODY()

		// 게임 시작 시 호출.
		void BeginPlay();

		// 소멸 시 호출.
		void EndPlay(const EEndPlayReason::Type EndPlayReason);

		// 모든 프레임에서 호출되어 이 액터를 업데이트.
		void Tick(float DeltaSeconds);
	};
Copy full snippet

블루프린트

언리얼 엔진의 컴포넌트에는 다양한 함수가 있습니다. 아래는 간단한 예제입니다.

C++

	UCLASS()
	class UMyComponent : public UActorComponent
	{
		GENERATED_BODY()

		// 소유 중인 액터 생성 후 호출
		void InitializeComponent();

		// 컴포넌트 또는 소유 중인 액터가 소멸 중일 때 호출.
		void UninitializeComponent();

		// 틱의 컴포넌트 버전
		void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction);
	};
Copy full snippet

블루프린트

예를 들어 유니티 C#에서는 base.Update() 가 여기 해당하지만, 언리얼 엔진 C++에서는 Super::TickComponent() 를 사용합니다.

	void UMyComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
	{
		// 여기에 틱 관련 커스텀 추가
		Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
	}
Copy full snippet

C++에서 어떤 클래스는 A 로, 어떤 클래스는 U 로 시작합니다. A 는 액터의 서브클래스, U 는 오브젝트 의 서브클래스를 나타냅니다. 그 밖의 흔히 쓰이는 접두사인 F 는 대부분 일반 데이터 구조체 또는 UObject 이외의 클래스에 사용됩니다.

언리얼 엔진에서 게임플레이 생성하기

다음 섹션에서는 고급 언리얼 엔진 프로그래밍 개념을 다룹니다. 아래 설명은 여러분이 유니티 C#에 익숙한 상태에서 언리얼 C++를 배우려는 학습자라고 가정합니다. 하지만 대부분의 경우 블루프린트로도 동일한 결과를 얻을 수 있기 때문에 가능하면 C++와 블루프린트 예제를 모두 추가했습니다.

가장 흔한 게임플레이 프로그래밍 패턴과 언리얼 엔진에서 사용할 수 있는 접근법을 살펴보겠습니다. 아래 예시는 대표적인 유니티 기능과 언리얼 엔진에서 동일한 기능을 구현하는 방법을 나타낸 것입니다.

게임 오브젝트 인스턴스화 / 액터 스폰하기

유니티에서는 Instantiate 함수를 사용하여 오브젝트의 새 인스턴스를 생성합니다. 이 함수는 게임 오브젝트, MonoBehaviour 등의 UnityEngine.Object 유형을 받아 사본을 만듭니다.

	public GameObject EnemyPrefab;
	public Vector3 SpawnPosition;
	public Quaternion SpawnRotation;

	void Start()
	{
		GameObject NewGO = (GameObject)Instantiate(EnemyPrefab, SpawnPosition, SpawnRotation);
		NewGO.name = "MyNewGameObject";
	}
Copy full snippet

언리얼 엔진에는 오브젝트를 인스턴스화하는 두 가지 함수가 있습니다.

• NewObject 는 새로운 UObject 유형을 생성합니다.
• SpawnActor 는 AActor 유형을 스폰합니다.

UObjects 및 NewObject

언리얼 엔진에서 UObject 의 서브클래스를 만드는 것은 유니티에서 ScriptableObject 의 서브클래스를 만드는 것과 매우 비슷합니다. 월드에 스폰할 필요가 없거나 액터처럼 컴포넌트에 어태치할 필요가 없는 게임플레이 클래스에 유용합니다.

유니티에서 ScriptableObject 의 자체 서브클래스를 생성한다면 아래와 같이 인스턴스화할 것입니다.

	MyScriptableObject NewSO = ScriptableObject.CreateInstance<MyScriptableObject>();
Copy full snippet

언리얼 엔진에서 자체 UObject 파생 유형을 만든다면 아래와 같이 인스턴스화할 것입니다.

	UMyObject* NewObj = NewObject<UMyObject>();
Copy full snippet

AActors 및 SpawnActor

액터는 SpawnActor 메서드를 사용하여 월드(C++의 UWorld ) 오브젝트에 스폰됩니다. 일부 UObject는 GetWorld 오브젝트 메서드를 제공합니다. 모든 액터를 예로 들 수 있습니다. 이 메서드를 통해 월드 오브젝트를 얻을 수 있습니다.

아래 예시에서는 다른 액터를 전달하는 대신, 스폰하고자 하는 액터의 클래스를 전달합니다. 여기서 클래스는 AMyEnemy의 모든 서브클래스가 될 수 있습니다.

하지만 유니티에서 Instantiate를 사용했을 때처럼 다른 오브젝트의 사본을 만들고 싶다면 어떻게 해야 할까요?

NewObject 와 SpawnActor 함수에도 작업할 템플릿 오브젝트를 줄 수 있습니다. 그러면 언리얼 엔진은 처음부터 오브젝트를 새로 만드는 것이 아니라 해당 오브젝트의 사본을 만듭니다. 그리고 UPROPERTY와 컴포넌트를 전부 복사합니다.

	AMyActor* CreateCloneOfMyActor(AMyActor* ExistingActor, FVector SpawnLocation, FRotator SpawnRotation)
	{
		UWorld* World = ExistingActor->GetWorld();
		FActorSpawnParameters SpawnParams;
		SpawnParams.Template = ExistingActor;
		World->SpawnActor<AMyActor>(ExistingActor->GetClass(), SpawnLocation, SpawnRotation, SpawnParams);
	}
Copy full snippet

위의 '처음부터'가 무슨 뜻인지 궁금하실 수 있습니다. 여러분이 생성하는 각 오브젝트 클래스에는 그 프로퍼티와 컴포넌트의 디폴트값이 포함된 디폴트 템플릿이 있습니다. 이 프로퍼티를 덮어쓰지 않고 별도의 템플릿을 제공해주지 않으면 언리얼 엔진은 이 디폴트값을 사용하여 오브젝트를 생성합니다. 이해를 돕기 위해 먼저 MonoBehaviour의 예시를 살펴보겠습니다.

	public class MyComponent : MonoBehaviour
	{
		public int MyIntProp = 42;
		public SphereCollider MyCollisionComp = null;

		void Start()
		{
			// 콜리전 컴포넌트가 없는 경우 생성
			if (MyCollisionComp == null)
			{
				MyCollisionComp = gameObject.AddComponent<SphereCollider>();
				MyCollisionComp.center = Vector3.zero;
				MyCollisionComp.radius = 20.0f;
			}
		}
	}
Copy full snippet

위 예제에는 디폴트값이 42인 int 프로퍼티와 기본 반경이 20인 SphereCollider 컴포넌트가 있습니다.

오브젝트의 생성자를 사용하여 언리얼에서도 똑같은 작업을 할 수 있습니다.

	UCLASS()
	class AMyActor : public AActor
	{
		GENERATED_BODY()

		UPROPERTY()
		int32 MyIntProp;

		UPROPERTY()
		USphereComponent* MyCollisionComp;

		AMyActor()
		{
			MyIntProp = 42;

			MyCollisionComp = CreateDefaultSubobject<USphereComponent>(FName(TEXT("CollisionComponent"));
			MyCollisionComp->RelativeLocation = FVector::ZeroVector;
			MyCollisionComp->SphereRadius = 20.0f;
		}
	};
Copy full snippet

AMyActor 생성자에서 클래스의 디폴트 프로퍼티 값을 설정했습니다. 특히 여기서는 CreateDefaultSubobject 함수를 사용했습니다. 이 함수를 사용하면 컴포넌트를 생성하고 여기에 디폴트 프로퍼티를 할당할 수 있습니다. 이 함수로 생성하는 서브오브젝트는 모두 디폴트 템플릿처럼 행동하므로 서브클래스나 블루프린트에서 변경할 수 있습니다.

한 유형에서 다른 유형으로 형변환하기

여기서는 이미 있다는 사실을 알고 있는 컴포넌트를 가져온 다음, 특정 유형으로 형변환한 뒤 조건에 따라 작업을 수행하겠습니다.

유니티 C#

	Collider collider = gameObject.GetComponent<Collider>;
	SphereCollider sphereCollider = collider as SphereCollider;
	if (sphereCollider != null)
	{
			// ...
	}
Copy full snippet

언리얼 엔진 C++

	UPrimitiveComponent* Primitive = MyActor->GetComponentByClass(UPrimitiveComponent::StaticClass());
	USphereComponent* SphereCollider = Cast<USphereComponent>(Primitive);
	if (SphereCollider != nullptr)
	{
			// ...
	}
Copy full snippet

게임 오브젝트 / 액터 소멸

유니티 Destroy(MyGameObject); Copy full snippet Destroy(MyGameObject);

C++ MyActor->Destroy(); Copy full snippet MyActor->Destroy();

블루프린트

게임 오브젝트 / 액터 소멸(1초 딜레이)

		Destroy(MyGameObject, 1);
Copy full snippet

		MyActor->SetLifeSpan(1);
Copy full snippet

게임 오브젝트 / 액터 비활성화

		MyGameObject.SetActive(false);
Copy full snippet

		// 눈에 보이는 컴포넌트 숨김
		MyActor->SetActorHiddenInGame(true);

		// 콜리전 컴포넌트 비활성화
		MyActor->SetActorEnableCollision(false);

		// 액터의 틱 중지
		MyActor->SetActorTickEnabled(false);
Copy full snippet

컴포넌트에서 게임 오브젝트 / 액터 액세스

		GameObject ParentGO =
		MyComponent.gameObject;
Copy full snippet

		 AActor* ParentActor =
		 MyComponent->GetOwner();
Copy full snippet

게임 오브젝트 / 액터에서 컴포넌트 액세스

유니티 C#

	MyComponent MyComp = gameObject.GetComponent<MyComponent>();
Copy full snippet

언리얼 엔진 C++

	UMyComponent* MyComp = MyActor->FindComponentByClass<UMyComponent>();
Copy full snippet

블루프린트

] 이미지를 클릭하면 최대 크기로 볼 수 있습니다.

게임 오브젝트 / 액터 찾기

유니티 C#

	// 이름으로 게임 오브젝트 찾기
	GameObject MyGO = GameObject.Find("MyNamedGameObject");

	// 유형으로 오브젝트 찾기
	MyComponent[] Components = Object.FindObjectsOfType(typeof(MyComponent)) as MyComponent[];
	foreach (MyComponent Component in Components)
	{
			// ...
	}

	// 태그로 게임 오브젝트 찾기
	GameObject[] GameObjects = GameObject.FindGameObjectsWithTag("MyTag");
	foreach (GameObject GO in GameObjects)
	{
			// ...
	}
Copy full snippet

언리얼 엔진 C++

	// 이름으로 액터 찾기(UObject에도 작동)
	AActor* MyActor = FindObject<AActor>(nullptr, TEXT("MyNamedActor"));

	// 유형으로 액터 찾기(UWorld 오브젝트 필요)
	for (TActorIterator<AMyActor> It(GetWorld()); It; ++It)
	{
			AMyActor* MyActor = *It;
			// ...
	}
Copy full snippet

블루프린트

언리얼 엔진 C++

	// 유형으로 UObject 찾기
	for (TObjectIterator<UMyObject> It; It; ++it)
	{
		UMyObject* MyObject = *It;
		// ...
	}

	// 태그로 액터 찾기(액터 컴포넌트에도 작동, 대신 TObjectIterator 사용)
	for (TActorIterator<AActor> It(GetWorld()); It; ++It)
	{
		AActor* Actor = *It;
		if (Actor->ActorHasTag(FName(TEXT("Mytag"))))
		{
			// ...
		}
	}
Copy full snippet

블루프린트

게임 오브젝트 / 액터에 태그 추가

유니티 C#

	MyGameObject.tag = "MyTag";
Copy full snippet

언리얼 엔진 C++

	// 액터는 여러 태그를 가질 수 있습니다
	MyActor.Tags.AddUnique(TEXT("MyTag"));
Copy full snippet

블루프린트

MonoBehaviour / 액터 컴포넌트에 태그 추가

유니티 C#

	// 어태치된 게임 오브젝트의 태그를 변경합니다
	MyComponent.tag = "MyTag";
Copy full snippet

언리얼 엔진 C++

	// 컴포넌트에는 자체 태그 배열이 있습니다
	MyComponent.ComponentTags.AddUnique(TEXT("MyTag"));
Copy full snippet

게임 오브젝트 / 액터 및 모노 비헤이비어 / 액터 컴포넌트의 태그 비교

유니티 C#

	if (MyGameObject.CompareTag("MyTag"))
	{
		// ...
	}

	// 어태치된 게임 오브젝트의 태그 확인
	if (MyComponent.CompareTag("MyTag"))
	{
		// ...
	}
Copy full snippet

언리얼 엔진 C++

	// 액터에 이 태그가 있는지 확인
	if (MyActor->ActorHasTag(FName(TEXT("MyTag"))))
	{
		// ...
	}
Copy full snippet

블루프린트

언리얼 엔진 C++

	// 액터 컴포넌트에 이 태그가 있는지 확인
	if (MyComponent->ComponentHasTag(FName(TEXT("MyTag"))))
	{
		// ...
	}
Copy full snippet

블루프린트

피직스: 리지드 바디 vs 프리미티브 컴포넌트

유니티에서는 게임 오브젝트에 물리 특성을 부여하려면 먼저 리지드 바디 컴포넌트를 주어야 합니다.

언리얼 엔진에서는 모든 프리미티브 컴포넌트(C++의 UPrimitiveComponent )가 물리 오브젝트가 될 수 있습니다. 대표적인 프리미티브 컴포넌트는 아래와 같습니다.

• 셰이프 컴포넌트(캡슐, 구체, 박스)
• 스태틱 메시 컴포넌트
• 스켈레탈 메시 컴포넌트

콜리전과 시각화를 별도의 컴포넌트가 분리해서 담당하는 유니티와 달리, 언리얼 엔진은 '물리적 가능성'과 '시각적 가능성'의 개념을 하나의 프리미티브 컴포넌트로 결합했습니다. 월드에 지오메트리를 가질 수 있는 컴포넌트라면, PrimitiveComponent 의 물리적인 서브클래싱을 통해 상호작용 또는 렌더링이 가능합니다.

레이어 vs 채널

언리얼 엔진의 콜리전 채널은 유니티의 레이어에 해당합니다. 자세한 정보는 콜리전 필터링을 참조하세요.

레이 캐스트 vs 레이 트레이스

유니티 C#

	GameObject FindGOCameraIsLookingAt()
	{
		Vector3 Start = Camera.main.transform.position;
		Vector3 Direction = Camera.main.transform.forward;
		float Distance = 100.0f;
		int LayerBitMask = 1 << LayerMask.NameToLayer("Pawn");

		RaycastHit Hit;
		bool bHit = Physics.Raycast(Start, Direction, out Hit, Distance, LayerBitMask);

		if (bHit)
		{
			return Hit.collider.gameObject;
		}

		return null;
	}
Copy full snippet

언리얼 엔진 C++

	APawn* AMyPlayerController::FindPawnCameraIsLookingAt()
	{
		// 이 부분을 사용하여 트레이스에 대한 다양한 프로퍼티를 커스터마이징할 수 있습니다
		FCollisionQueryParams Params;
		// 플레이어의 폰을 무시합니다
		Params.AddIgnoredActor(GetPawn());

		// 라인 트레이스로 충돌 결과를 채웁니다
		FHitResult Hit;

		// 카메라에서 나온 레이캐스트로, 폰과만 충돌합니다(ECC_Pawn 콜리전 채널에 존재)
		FVector Start = PlayerCameraManager->GetCameraLocation();
		FVector End = Start + (PlayerCameraManager->GetCameraRotation().Vector() * 1000.0f);
		bool bHit = GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, Params);

		if (bHit)
		{
			// Hit.Actor에는 충돌을 트레이싱하는 액터의 위크 포인터가 있습니다
			return Cast<APawn>(Hit.Actor.Get());
		}

		return nullptr;
	}
Copy full snippet

블루프린트

이미지를 클릭하면 최대 크기로 볼 수 있습니다.

트리거 볼륨

유니티 C#

	public class MyComponent : MonoBehaviour
	{
		void Start()
		{
			collider.isTrigger = true;
		}
		void OnTriggerEnter(Collider Other)
		{
			// ...
		}
		void OnTriggerExit(Collider Other)
		{
			// ...
		}
	}
Copy full snippet

언리얼 엔진 C++

	UCLASS()
	class AMyActor : public AActor
	{
		GENERATED_BODY()

		// 내 트리거 컴포넌트
		UPROPERTY()
		UPrimitiveComponent* Trigger;

		AMyActor()
		{
			Trigger = CreateDefaultSubobject<USphereComponent>(TEXT("TriggerCollider"));

			// 두 콜라이더 모두 이 옵션이 true로 설정되어 있어야 이벤트가 발동됩니다
			Trigger.bGenerateOverlapEvents = true;

			// 콜라이더에 대한 콜리전 모드를 설정합니다
			// 이 모드는 레이캐스트, 스윕, 오버랩에 대한 콜라이더만 활성화시킵니다
			Trigger.SetCollisionEnabled(ECollisionEnabled::QueryOnly);
		}

		virtual void NotifyActorBeginOverlap(AActor* Other) override;

		virtual void NotifyActorEndOverlap(AActor* Other) override;
	};
Copy full snippet

언리얼 엔진 블루프린트

키네마틱 리지드 바디

유니티 C#

	public class MyComponent : MonoBehaviour
	{
		void Start()
		{
			rigidbody.isKinematic = true;
			rigidbody.velocity = transform.forward * 10.0f;
		}
	}
Copy full snippet

언리얼 엔진 4에서는 콜리전 컴포넌트와 리지드 바디 컴포넌트가 하나입니다. 이 베이스 클래스는 UPrimitiveComponent 로, 필요에 따라 USphereComponent, UCapsuleComponent 등 여러 서브클래스를 가집니다.

언리얼 엔진 C++

	UCLASS()
	class AMyActor : public AActor
	{
		GENERATED_BODY()

		UPROPERTY()
		UPrimitiveComponent* PhysicalComp;

		AMyActor()
		{
			PhysicalComp = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionAndPhysics"));
			PhysicalComp->SetSimulatePhysics(false);
			PhysicalComp->SetPhysicsLinearVelocity(GetActorRotation().Vector() * 100.0f);
		}
	};
Copy full snippet

입력 이벤트

유니티 C#

	public class MyPlayerController : MonoBehaviour
	{
		void Update()
		{
			if (Input.GetButtonDown("Fire"))
			{
				// ...
			}
			float Horiz = Input.GetAxis("Horizontal");
			float Vert = Input.GetAxis("Vertical");
			// ...
		}
	}
Copy full snippet

언리얼 엔진 C++:

	UCLASS()
	class AMyPlayerController : public APlayerController
	{
		GENERATED_BODY()

		void SetupInputComponent()
		{
			Super::SetupInputComponent();

			InputComponent->BindAction("Fire", IE_Pressed, this, &AMyPlayerController::HandleFireInputEvent);
			InputComponent->BindAxis("Horizontal", this, &AMyPlayerController::HandleHorizontalAxisInputEvent);
			InputComponent->BindAxis("Vertical", this, &AMyPlayerController::HandleVerticalAxisInputEvent);
		}

		void HandleFireInputEvent();
		void HandleHorizontalAxisInputEvent(float Value);
		void HandleVerticalAxisInputEvent(float Value);
	};
Copy full snippet

블루프린트

프로젝트 세팅의 입력 프로퍼티는 아래와 같은 모습입니다.

FAQ

지난 프로젝트는 어떻게 자동으로 로드하나요?

언리얼 엔진에서는 작업하던 프로젝트를 시작 시 자동으로 로드하도록 환경설정할 수 있습니다. 에픽 런처에서 프로젝트를 열 때 시작 시 항상 마지막 프로젝트를 로드합니다(Always load last project on Startup) 를 활성화하면 됩니다.

게임의 입력 바인딩 설정은 어디서 하나요?

유니티에서는 프로젝트의 입력 매니저(Input Manager) 세팅을 사용하여 디폴트 바인딩을 구성했습니다.

언리얼 엔진에서는 프로젝트 세팅 을 연 다음 입력(Input) 카테고리에서 입력 바인딩을 환경설정합니다. 이 창에서는 다양한 버튼(액션) 및 아날로그 컨트롤(축)을 추가할 수 있습니다. 각 컨트롤에 이름과 디폴트 바인딩을 설정합니다. 이제 입력 이벤트가 트리거되면 게임의 폰에 대한 콜백을 구할 수 있습니다.

언리얼 엔진 프로젝트의 입력을 구성하는 자세한 방법은 입력 페이지를 참조하세요.

프로젝트의 시작 씬은 어떻게 바꾸나요?

프로젝트를 열면 언리얼 엔진은 기본으로 디폴트 레벨을 로드합니다. 이 비헤이비어는 메인 메뉴의 편집 > 프로젝트 세팅 을 선택하면 열리는 프로젝트 세팅 창에서 일반(General) > 로드 & 저장(Loading & Saving) 카테고리를 클릭해 변경할 수 있습니다.

게임은 어떻게 실행하나요?

게임을 테스트(실행)하는 방법은 많습니다.

• 언리얼 에디터에서 바로 메인 툴바 의 플레이(Play) 버튼을 클릭합니다.

• 독립형 프로세스의 경우, 메인 툴바 의 플랫폼 을 클릭한 뒤 드롭다운 목록에서 해당하는 기기를 선택합니다. 이렇게 하면 먼저 플랫폼에 대한 실행파일이 빌드됩니다. 예를 들어, Windows 기기에서 작업 중이라면 Windows 실행파일이 빌드됩니다.

• 모바일 기기나 웹 브라우저 등 다른 플랫폼의 경우, 메인 툴바 의 플랫폼 버튼을 클릭한 뒤 게임을 실행하고 싶은 플랫폼을 선택합니다. 먼저 필요한 모든 종속성을 설치해야 합니다.

다양한 플랫폼에서 언리얼 엔진을 실행하는 자세한 방법은 아래 페이지를 참조하세요.

• 플레이 및 시뮬레이션

• 언리얼 에디터에서 플랫폼 관리

단위는 어떻게 되나요?

유니티의 주된 측정 단위는 1미터입니다. 언리얼 엔진의 주된 측정 단위는 1센티미터입니다.

즉, 유니티에서 대상을 1유닛(미터) 옮기면 언리얼 엔진에서 100유닛(센티미터) 옮기는 것과 같습니다.

유니티에서 대상을 2피트 옮기는 경우 0.61유닛(미터) 옮기는 것입니다. 언리얼 엔진에서는 61유닛(센티미터)이 됩니다.

언리얼 엔진의 좌표계에서는 어디가 윗쪽인가요?

유니티와 언리얼 엔진 둘 다 왼손 좌표계를 사용하지만 축 이름은 다릅니다. 언리얼 엔진에서는 양수 X가 '앞쪽', 양수 Y가 '오른쪽', 양수 Z가 '윗쪽'입니다.

게임의 로그 출력은 어떻게 확인하나요?

하단 툴바 에서 출력 로그(Output Log) 버튼을 클릭합니다.

예외 처리는 어떻게 하나요?

유니티와 달리 언리얼 엔진에서는 예외 처리를 사용하지 않습니다. 대신 check() 함수를 사용하여 치명적인 어서트 오류를 발동시킵니다. 오류 메시지를 통해 전달할 수 있습니다. 오류 보고는 하지만 프로그램을 멈추고 싶지는 않은 경우, ensure() 를 대신 사용합니다. 전체 콜 스택을 포함해 오류는 기록되지만 프로그램은 계속 실행합니다. 디버거가 어태치된 경우, 두 함수 모두 디버거로 들어갑니다.

.NET 프레임워크는 어디에 있나요?

유니티와 달리 언리얼 엔진은 .NET 프레임워크를 사용하지 않습니다. 언리얼 엔진에는 별도의 컨테이너 클래스와 라이브러리가 있습니다. 아래는 주요 컨테이너를 비교한 목록입니다.

언리얼 엔진 컨테이너와 관련된 자세한 정보는 여기에서 확인할 수 있습니다.

언리얼은 코드 변경사항을 자동으로 로드하나요?

네! 코드를 작성하면서 에디터를 열어둬도 됩니다. 코드 편집을 마친 다음 Visual Studio에서 컴파일을 시작하면 에디터가 변경사항을 자동으로 '핫 리로드'합니다.

도움말

읽어주셔서 감사합니다! 이 가이드는 각지에 있는 언리얼 개발자들의 도움으로 언리얼 커뮤니티를 위해 처음 작성되었으며, 언리얼 엔진 5에 맞게 업데이트되었습니다. 언리얼 엔진으로 전환하는 과정에서 가장 유용한 정보가 무엇인지 연구하며 계속 문서를 개선할 예정이므로 피드백과 수정할 부분을 알려주시면 감사하겠습니다.

언리얼 엔진에 대해 자세히 알고 싶다면 이 문서 웹사이트를 참조하거나 아래 참고 자료 페이지를 방문하시기 바랍니다.

• 언리얼 엔진 YouTube 채널
• 포럼
• 커뮤니티 리소스