[Unity Associate Programmer 자격증 준비] 이론개념 정리

씬 플로 및 데이터 관리

실시간 3D 경험 디자인 소개 - Unity Learn

1. 씬 플로 데이터 관리

1) 실시간 3D 경험 디자인 소개

 

[디자인 프로세스]

Pre-projection -> Production -> Post-production -> Operations

사전 제작 -> 정식제작 -> 사후 제작 -> 운영

 

파이프라인 관리에 있어서 디자인 프로세스는 제작 사이클의 앞 3 단계인 사전 제작, 정식 제작, 사후 제작에 해당한다.

구체적인 단계는 아래와 같다.

 

1단계: 문제 파악 또는 아이디어 정의

2단계: 사용자 및 시장 조사 진행

3단계: 사용자 페르소나 생성 및 사용 사례 정의

4단계: 브리프 개선 및 목표 명확화

5단계: 예비 디자인 만들기

6단계: 프로토타이핑

7단계: 반복 디자인 및 개발 (프로토타입을 승인하면 디자인 -> 제작 -> 테스트 -> 평가 -> 디자인 개선 작업을 계속 반복함)

 

[디자인 및 개발 접근 방식]

1) 워터풀 접근 방식

마치 폭포가 아래로 흐르는 것처럼 한 단계가 완료되고 승인되면 다음 단계가 시작됨.

 

2) 애자일 접근 방식

과정 반복적인 접근 방식

 

3) 하이브리드 접근 방식

애자일 + 워터풀 요소한 방식. 프로젝트 사전 제작 과정에서 선형적인 방식으로 준비를 완료한 다음, 특정 기능에 중점을 둔 사이클에서 반복적으로 제작 및 테스트하는 작업이 포함될 수 있음.

 

2. 버전 관리 설정

모든 종류의 파일이나 소프트웨어, 웹사이트, 기타 데이터에 대한 변경 사항을 저장, 관리, 추적하도록 설정할 수 있음.

개인이나 소규모 팀, 대규모 조직은 복잡한 프로젝트를 간편하게 백업하고 관리하기 위해 버전 관리 시스템을 사용.

버전관리를 일관되게 조율하지 않으면 비효율성, 병목 현상, 코드 손실, 재작업 등 많은 고충에 직면할 수 있음.

 

[버전 관리 시스템의 기능 3가지]

1) 백업 스토리지

2) 수정 사항 추적

3) 프로젝트 관리

 

[버전 관리의 작동 방식]

1) 변경 사항 푸쉬 및 풀

2) 변경 사항 병합

3) 이전 버전으로 되돌리기.

 

예시 퀴즈)

정답) 4번. 저장소의 여러 브랜치에서 동일한 파일의 같은 라인을 변경하는 경우.

 

3. 객체 지향 프로그래밍의 원칙

서로 관련있는 메서드와 변수를 그룹화하여 오브젝트를 생성하는 것.

 

[객체 지향 프로그래밍의 4가지 원칙]

1) 추상화: 다르프로그래머가 볼 수 있는 스크립트에서 복잡한 코드를 제거하고 다른 프로그래머에게 실제로 필요한 기능만 노출하는 프로세스.

2) 상속: 자식 클래스를 만들 수 있는 기본 클래스를 만드는 프로세스.

자식 클래스는 부모 클래스(기본 클래스)의 모든 기능을 자동으로 가져옴.

3) 다형성: 부모 클래스에서 상속된 코드를 커스텀 할 수 있음.

부모 클래스의 메서드를 자식 클래스에서 오버라이드해서 커스텀 코드를 작성할 수 있음.

4) 캡슐화: 코드 간결화 및 안정성을 위해 접근성을 제어하는 것. 

 

4. 씬 플로 생성

using UnityEngine.SceneManagement;

네임스페이스 추가

public void StartNew(){
    SceneManager.LoadScene(1);
}

새로운 씬 호출.

LoadScene(씬 인덱스) 함수 안의 인자는 Build Settings에 있는 씬 인덱스 이다.

Build Settings 창은 File > Build Settings에 있다.

 

예시문항)

* 조건부 컴파일

#if UNITY_EDITOR
using UnityEditor;
#endif

public void Exit()
    {
#if UNITY_EDITOR
        EditorApplication.ExitPlaymode();
#else
        Application.Quit(); // Unity 플레이어를 종료하는 원본 코드
#endif
    }

애플리케이션 종료 함수인 Application.Quit() 가 에디터상에서는 안먹는다.

위와 같이 조건부 컴파일을 사용해서 Editor일때는 EditorApplication.ExitPlaymode() 함수를 호출해서 종료해야 한다.

콘솔에 'The name 'EditorApplication' does not exist in the current context'라는 오류가 나타나면 UnityEditor 네임스페이스를 추가해주자.

 

5. 씬간 데이터 지속성 구현

public class MainManager : MonoBehaviour{

    public static MainManager Instance;

    private void Awake(){
        if(Instance == null) Instance = this;
        DontDestroyOnLoad(gameObject);
    }
}

DontDestroyOnLoad 메서드를 사용해야 한다.

 

static 키워드는 이 클래스 멤버에 저장된 값이 해당 클래스의 모든 인스턴스에서 공유됨을 의미한다.

예를 들어 한 씬에 MainManager Instance가 10개 있는 경우, 모든 인스턴스에 저장된 값이 동일하다. 하나라도 변경되면 나머지 9개도 변경된다.

 

이 때, Awake() 함수 안에서 if(Instance == null) 구문이 없을 경우, 씬을 다시 돌아올 때마다 계속 MainManger 객체가 생성되는 문제가 있을 수 있다. 즉 씬을 재로드했을 때 MainManger 가 있으면 또 생성하지 않도록 조건문을 추가해줘야 한다.

이게 바로 싱글톤이다.

 

6. 세션 간 데이터 지속성 구현

{
  "name": "John",
  "age": 27,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York"
  }
  "pet": [“dog”, “cat”]
}

세션 간 데이터를 유지하려면 어떤 방식으로든 데이터를 저장해야 한다.

데이터를 저장가능한 형식으로 바꾸는 것을 Serialization(직렬화), 저장된 형식을 데이터로 바꾸는 걸 Deserialization(역직렬화)라고 한다.

 

Unity에서 데이터 저장에 흔히 사용되는 Json 형식은 JavaScript Object Notation 의 약자이다.

Key : Value 페어로 동작한다.

Obejct는 {} 중괄호로, 배열은 [] 대괄호로 묶인다.

 

Unity에는 JsonUtility라는 헬퍼 클래스가 있다.

JsonUtility는 직렬화 가능한 유형인 MonoBehaviour 또는 [Serializable] 속성을 추가할 수 있도록 작성하는 다른 클래스/구조체에서만 작동한다.

JsonUtility는 기본형, 배열, 리스트, 딕셔너리에서 작동하지 않는다.

[Serializable]
public class PlayerData
{
    public int level;
    public Vector3 position;
    public string playerName;
}

위와 같은 PlayerData 데이터 클래스가 있다.

PlayerData myData = new PlayerData();
myData.level = 1;
myData.position = new Vector3(3.0f, 4.4f, 2.3f);
myData.playerName = "John";

위처럼 playerData 객체를 만든다. 

string json = JsonUtility.ToJson(myData);

ToJson 함수를 이용하면 myData 객체가 아래처럼 json 형식으로 바뀐다.

    “level”: 1,
    “position”: {
        “x” : 3.0,
        “y” : 4.4,
        “z” : 2.3 },
    “playerName”: “John”

PlayerData myData = JsonUtility.FromJson<PlayerData>(json);

반대로 FromJson 함수를 이용하면 myData가 JSON 문자열의 값으로 채워집니다.

 

//File을 이용한 json 파일 저장 및 로드 코드 예시

using System.IO;

[System.Serializable]
class SaveData{
    public Color TeamColor;
}

public void SaveColor(){
    SaveData data = new SaveData();
    data.TeamColor = TeamColor;

    string json = JsonUtility.ToJson(data);
  
    File.WriteAllText(Application.persistentDataPath + "/savefile.json", json);
}

public void LoadColor(){
    string path = Application.persistentDataPath + "/savefile.json";
    if (File.Exists(path)){
        string json = File.ReadAllText(path);
        SaveData data = JsonUtility.FromJson<SaveData>(json);

        TeamColor = data.TeamColor;
    }
}

---

객체지향 원칙 적용

주니어 프로그래머: 객체 지향 원칙 적용 - Unity Learn

 

1. 객체 지향 프로그래밍의 추상화

*추상화: 다른 프로그래머가 볼 수 있는 스크립트에서 복잡한 코드를 제거하고 실제로 필요한 기능만 노출하는 프로세스.

복잡한 내부 작동 방식을 추상적이면서 재사용 가능성이 더 높은 코드로 대체한다.

 

예로, 4단원 게임플레이 메카닉 프로젝트(공놀이)에서 Enemy 객체를 생성하는 코드를 살펴보자.

private void Start(){
    for (int i = 0; i < 3; i++){
        Instantiate(enemyPrefab, GenerateSpawnPosition(),   
        enemyPrefab.transform.rotation);
    }
}

위와 같이 Start() 문에 Enemy 객체 생성코드를 넣으면 실행시 1번만 실행되고, 다시 생성하려면 다른 함수에 저 코드를 복사붙여넣기 해야한다. 중복코드가 발생하며 비효율적이다.

// 더 높은 수준의 메서드 새로 생성 
void SpawnEnemyWave() {
    for (int i = 0; i < 3; i++){
        Instantiate(enemyPrefab, GenerateSpawnPosition(), 
        enemyPrefab.transform.rotation);
    }
}

private void Start(){
    SpawnEnemyWave(); // Start()로 더 높은 수준의 메서드 호출
}

 위와 같이 중복될 코드를 SpawnEnemyWave() 함수라는 더 높은 수준의 메서드를 생성하면 Enemy 객체의 생성이 필요할 때, 함수 하나만 호출해주면 된다. 다른 고민은 할 필요가 없다. 수정시에도 SpawnEnemyWave() 함수 안에서 한번만 수정하면 된다. 구현작업이 더 간단하게 개선되었다. 이러한 작업을 추상화라고 한다.

 

2. 객체 지향 프로그래밍의 상속과 다형성

*상속: 기본 클래스(부모 클래스)를 생성하는 프로세스. 이 기본 클래스를 기반으로 다른 클래스(자식 클래스)를 만듬.

자식 클래스는 부모 클래스의 모든 기능을 자동으로 가져오며 이를 상속이라 함.

public class SomeClass : MonoBehaviour { }

Unity에서 MonoBehaviour가 기본 클래스 역할임. MonoBehaviour를 상속받기에 OnTriggerEnter(), GetComponent, Start(), Update() 등의 구문을 사용할 수 있음.

 

*다형성: 부모에게 상속받은 기능을 변경하여 커스텀 하는 것.

public class Enemy : MonoBehaviour { 
    public void DealDamage () {
        Player.Health -= 10;
    }
}

public class Thief : Enemy {
    private void Update() {
        if (Player.isSeen) {
            DealDamage(); // 부모 클래스로부터 메서드를 호출할 수 있음
        }
    }
}

Thief 클래스의 Update()문에서 호출한 DealDamage() 함수는 부모 클래스 Enemy 의 DealDamage() 함수를 호출한다.

 

부모 클래스에 작성된 함수를 고대로 사용 안하고 커스텀하기 위해 재선언 하려면 어떻게 해야할까.

public class Enemy : MonoBehaviour { 
    public virtual void DealDamage () { // 가상 키워드가 오버라이드를 허용함
        Player.Health -= 10;
    }
}

부모 클래스에서 virtual 키워드로 함수를 구현한다.

부모 클래스에서 메서드를 virtual로 식별하면 오버라이드가 가능하나 필수는 아니게 된다.

참고로 오버라이드가 선택 사항인 virtual 메서드와 달리, abstract 표기를 사용하며 반드시 오버라이드되어야 한다.

public class Thief : Enemy {

    // 부모 클래스의 가상 메서드를 오버라이드할 수 있음
    public override void DealDamage() {
        Player.Health -= 2;
        CommitPettyTheft();
    }
    
    private void Update() {
        if (Player.isSeen) {
            DealDamage();
        }
    }
}

그러면 자식 클래스에서 override 키워드로 DealDamage() 함수를 재구현할 수 있다.

이 때, 자식클래스의 Update()문에서 DealDamage()는 Thief 클래스 내부에서 override 한 DealDamage() 함수를 의미한다.

 

만약 base 레이블을 사용하여 base.DealDamage(); 로 호출했다면, 원래 메서드를 실행하라는 뜻이 된다.

 

public virtual void GoTo(Building target){
    m_Target = target;

    if (m_Target != null) {
        m_Agent.SetDestination(m_Target.transform.position);
        m_Agent.isStopped = false;
    }
}

public virtual void GoTo(Vector3 position){
    m_Target = null;
    m_Agent.SetDestination(position);
    m_Agent.isStopped = false;
}

또한, 상속/다형성의 경우 같은 이름을 가진 함수를 인자를 달리하여 여러개 만들 수 있다.

 

public void Translate(Vector3 translation); 
// transform.Translate(Vector3.forward);로 구현됨

public void Translate(float x, float y, float z); 
// transform.Translate(0, 0, 1);로 구현됨

public void Translate(Vector3 translation, Transform relativeTo);
// transform.Translate(Vector3.forward, Space.Self);로 구현됨

public void Translate(float x, float y, float z, Transform relativeTo); 
// transform.Translate(0, 0, 1, Space.Self);로 구현됨

Unity Rigidbody 의 Translate 함수가 인자만 다르고 여러개 정의되어 있는 예시를 보면 확 와닿을 것이다.

 

예시문항)

 

* 확장메서드

: 기존 클래스의 기능을 확장하는 기법. 상속과는 다름

클래스의 외부에서 클래스의 메서드처럼 사용할 수 있는 새로운 메서드를 만드는 기능.

확장메서드는 static 클래스에서 정의해야 한다.

public class OriginClass {
  public void Print1(){
    Console.WriteLine("Print1() Method Call");
  }
  public void Print2(){
    Console.WriteLine("Print2() Method Call");
  }
  public void Print3(){
    Console.WriteLine("Print3() Method Call");
  }
}

public static class ExtensionMethod {
  public static void Print4(this OriginClass O){
    Console.WriteLine("Print4() Method Call");
  }
  public static void Print5(this OriginClass O, String str){
    Console.WriteLine("Print5() Method Call");
    Console.WriteLine("Print5() Param: " + str);
  }
}

class Program{
  static void Main(string[] args){
    OriginClass originClass = new OriginClass();
    originClass.Print4();
    originClass.Print5("Hello!");
  }
}

출처: https://developer-talk.tistory.com/477

 

예시문항)

 

*인터페이스

: 인터페이스에서 몸체없는 메서드를 만들어주고 클래스들에서 상속받아서 사용한다.

: 단 상속받은 클래스들은 인터페이스의 멤버를 반드시 구현해줘야 한다.

: 추상 클래스와의 차이점은 추상클래스는 다중상속을 지원하지 않지만 인터페이스는 다중상속을 지원하며, 인터페이스 자체로 인스턴스 생성이 안된다.

namespace InterfaceEx{

    class Program {
        static void Main(string[] args) {
            Person myPerson = new Person();
            Lion myLion = new Lion();
            Camel myCamel = new Camel();

            myPerson.Eat();
            myLion.Eat();
            myCamel.Eat();

            Console.WriteLine();

            MyEatFunc(myPerson);
            MyEatFunc(myLion);
            MyEatFunc(myCamel);
        }

        private static void MyEatFunc(object obj) {
            IAnimal target = obj as IAnimal;
            if (target != null) {
                target.Eat();
            }
        }
    }
    
    class Person : IAnimal{
        public void Eat(){ Console.WriteLine("밥을 먹습니다."); }
    }

    class Lion : IAnimal{
        public void Eat() { Console.WriteLine("고기를 먹습니다."); }
    }

    class Camel {
        public void Eat(){  Console.WriteLine("풀을 먹습니다."); }
    }

    interface IAnimal{
        void Eat();
    }
}

출처: https://frozenpond.tistory.com/27

 

=> 실행결과:

밥을 먹습니다.

고기를 먹습니다.

풀을 먹습니다.

 

밥을 먹습니다.

고기를 먹습니다.

 

=> 해석:

MyEatFunc(object obj) 함수에서 myCamel은 IAnimal 인터페이스를 상속받고 있지 않기 때문에 target이 되지 않아서 Eat() 함수를 실행하지 않는다.

 

3. 객체 지향 프로그래밍의 캡슐화

코드의 안정성을 위해 액세스 권한을 제어할 수 있도록 감싸는 것.

코드가 원래 의도한 대로만 사용되고 프로그래머가 조작하는 값과 데이터가 손상되지 않도록 보장하는 프로세스.

*접근제어자: private, public, protected, default

 

1) private 변수 인스펙터에 노출시키기

public class Rabbit : MonoBehaviour {
    [SerializeField] // 인스펙터에 private 변수 표시
    private Color furColor;
}

원래 private 접근제어자를 사용하면 인스펙터에 노출이 안된다.

하지만, 직렬화를 이용해서 [SerializeField] 태그를 추가하여 private 변수를 인스펙터에 노출하면서도 다르 코드에서는 노출하지 않도록 만들 수 있다.

 

2) public 변수 보호하기

public static MainManager Instance;

public 이어야만 하는 변수를 보호하는 방법은 static 키워드를 이용한다.

하지만 Instance에 접근할 get(), se() 함수가 없다면 MainManager.Instance 호출 시 에러가 난다.

public static MainManager Instance
{
    get {return Instance;}
    set {Instance = this;}
}

유니티에서는 get, set 키워드를 사용해서 자동으로 get(), set() 기능을 제공하는 프로퍼티가 있다.

public static MainManager Instance { get; set; } // private 세터 추가

더 나아가서 get, set 프로퍼티 안에 return, 대입 구문을 안넣어도 되는 자동 구현 프러퍼티 기능을 제공한다.

 

3) get, set 시, 조건 부여하기

private float m_ProductionSpeed = 0.5f;

public float ProductionSpeed // 세미콜론 삭제
{
    get { return m_ProductionSpeed; } // 게터에서 지원 필드 반환
    set { m_ProductionSpeed = value; } // 세터에서 지원 필드 사용
}

위 처럼 public 프로퍼티에 액세스할 때 지원 필드를 가져오거나 할당하는 get 및 set 함수를 수동으로 추가할 수도 있다.

set{
    if (value < 0.0f) {
    	Debug.LogError("You can't set a negative production speed!");
    }
    else{
    	m_ProductionSpeed = value; // 원래 세터가 현재 if/else 문에 있음
    }
}

위 처럼 조건문을 추가해서 지정해줄 수도 있다.

 

4. 코드 프로파일링

*유니티 프로파일러: 스크립트 호출, 메모리 할당, 렌더링 등 프로젝트 성능에 영향을 미치는 모든 것을 확인할 수 있다.

Window > Analysis > Profiler

프로파일러 실행 화면

상단: CPU 사용 현황이 담긴 차트가 보여짐.

하단: 각 프레임에 어떤 일이 발생하는지 시각적으로 요약된 내용이 보여짐.

 

위 이미지를 보면 Scripts에 엄청난 시간이 소요되는 것을 볼 수 있음. 즉 Script에 문제가 있을 가능성이 많음.

상단 그래프에서 CPU 사용량이 급증하는 구간을 클릭해서 하단을 살펴보면 CPU: 117.26ms 임을 알 수 있음

CPU ms는 해당 프레임의 모든 작업을 완료하는 데 소요된 총 시간(밀리초)을 나타냅니다.

 

1,000ms / 목표 초당 프레임 수 = 밀리초 예산

 

목표 초당 프레임수가 60FPS이라면 각 프레임의 밀리초 예산은 16임. 117.26ms는 약 7배...

 

* Player Loop: 게임 자체에서 실행 중인 모든 작업

* EditorLoop: 에디터에서 애플리케이션을 실행할 때 발생하는 모든 작업.

=> 실제 게임은 Editor에서 하는게 아니므로 Player loop만 보면 됨.

 

* 코드의 특정 섹션 프로파일링

Profiler.BeginSample("Moving"); // 프로파일링 시작    
Move();    
Profiler.EndSample(); // 프로파일링 종료

특정 부분에 Profiler.BeginSample(), Profiler.EndSample() 을 실행하면 프로파일러에서 문제가 생긴 부분을 구체적으로 알 수 있다.

 

void Move() {
    Vector3 position = transform.position;

    float distanceToCenter = Vector3.Distance(Vector3.zero, position);
    float speed = 0.5f + distanceToCenter / areaSize.magnitude;

    int steps = Random.Range(1000, 2000);
    float increment = Time.deltaTime / steps;
    for (int i = 0; i < steps; ++i) {
        position += currentVelocity * increment * speed;
    }

    transform.position = position;
    transform.position = transform.position + currentVelocity * Time.deltaTime;
}

void Move() {
    transform.position = transform.position + currentVelocity * Time.deltaTime;
}

Move함수의 긴 코드를 이동행위만 하도록 1줄로 변경하였다.

 

코드 변경후 다시 프로파일러를 돌려보자.

이전에는 Move 코드를 완료하는 데 99.74ms가 소요되엇는데, 최적화 변경 후에는 소요 시간이 1.08ms 이다.

총 CPU ms도 타겟인 16ms보다 짧은 14.94ms로 단축되었다.