#pragma once
#include "DrawDebugHelpers.h"



#define DRAW_SPHERE(Location) if (GetWorld()) DrawDebugSphere(GetWorld(), Location, 25.f, 12, FColor::Red, true);
#define DRAW_LINE(StartLocation, EndLocation) if (GetWorld()) DrawDebugLine(GetWorld(), StartLocation, EndLocation, FColor::Red, true, -1.f, 0, 1.f);
#define DRAW_POINT(Location) if (GetWorld()) DrawDebugPoint(GetWorld(), Location, 15.f, FColor::Red, true);
#define DRAW_VECTOR(StartLocation, EndLocation) if(GetWorld()) \
    { \
        DrawDebugLine(GetWorld(), StartLocation, EndLocation, FColor::Red, true, -1.f, 0, 1.f); \
        DrawDebugPoint(GetWorld(), EndLocation, 15.f, FColor::Red, true); \
    }

디버그 그리기

void AItem::BeginPlay()
{
    Super::BeginPlay();

    UWorld* World = GetWorld();
    FVector Location = GetActorLocation();
    FVector Forward = GetActorForwardVector();

    DRAW_SPHERE(Location);
    //DRAW_LINE(Location, Location + Forward * 100.f);
    //DRAW_POINT(Location + Forward * 100.f);
    DRAW_VECTOR(Location, Location + Forward * 100.f);

}

Output Log, ScreenDebugMesssage 문자 출력하기

// Fill out your copyright notice in the Description page of Project Settings.


#include "Items/Item.h"

AItem::AItem()
{
    PrimaryActorTick.bCanEverTick = true;

}

void AItem::BeginPlay()
{
    Super::BeginPlay();

    UE_LOG(LogTemp, Warning, TEXT("BEGIN PLAY CALLED!"));

    if (GEngine)
    {
        GEngine->AddOnScreenDebugMessage(1, 60.f, FColor::Cyan, FString("Item OnScreen Message!"));
    }

}

void AItem::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    UE_LOG(LogTemp, Warning, TEXT("DELTATIME: %f"), DeltaTime);

    if (GEngine)
    {
        FString Name = GetName();
        FString Message = FString::Printf(TEXT("ItemName: %s"), *Name);
        GEngine->AddOnScreenDebugMessage(1, 60.f, FColor::Cyan, Message);

        UE_LOG(LogTemp, Warning, TEXT("ItemName: %s"), *Name);
    }
}

https://mentum.tistory.com/416

            //CharacterController : Move()

            //- 인자는 float(방향 x 속도 x deltaTime를 곱해서 넘겨주자)

            //- 중력을 받지않는다! 때문에 중력은 수동으로 속도에 곱해줘야한다.

​

            //CharacterController : SimpleMove()

            //- 인자는 float(방향 x 속도를 곱해서 넘겨주자)

            //- 지면방향 움직임만 설정하면 중력은 자동으로 계산된다.

​

            //controller.Move(moveDir * Time.deltaTime * moveSpeed);

            // 캐릭터에 중력 적용

            m_ChrController.SimpleMove(moveDir * moveSpeed);

using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; using UnityEngine.SceneManagement;

public class Fade_Mgr : MonoBehaviour { public bool IsFadeOut = false; //나갈때 public bool IsFadeIn = false;

//--- Fade In Out 관련 변수들...
Image m_FadeImg = null;
float AniDuring = 0.8f;     //페이드아웃 연출 시간 설정
bool  m_StartFade = false;
float m_CacTime = 0.0f;
float m_AddTimer = 0.0f;
Color m_Color;

float m_StVal = 1.0f;
float m_EndVal = 0.0f;

string m_SceneName = "";    //이동할 씬 이름 저장용 변수
//--- Fade In Out 관련 변수들...

public static Fade_Mgr Inst = null;

void Awake()
{
    Inst = this;    
}

// Start is called before the first frame update
void Start()
{
    GameObject a_Canvas = GameObject.Find("Canvas");
    if(a_Canvas != null)
    {
        //매개변수 true의 의미는 Active가 껴져 있는 게임오브젝트도 모두 가져오라는 뜻
        Image[] a_ImgList = a_Canvas.transform.GetComponentsInChildren<Image>(true);
        for(int ii = 0; ii < a_ImgList.Length; ii++)
        {
            if(a_ImgList[ii].gameObject.name == "FadePanel")
            {
                m_FadeImg = a_ImgList[ii];
                break;
            }
        }

    } //if (a_Canvas != null)

    //--- Fade In 초기화
    if(m_FadeImg != null && IsFadeIn == true)
    {
        m_StVal = 1.0f;
        m_EndVal = 0.0f;
        m_FadeImg.color = new Color32(0, 0, 0, 255);
        m_FadeImg.gameObject.SetActive(true);
        m_StartFade = true;
    }
    //--- Fade In 초기화

}//void Start()

// Update is called once per frame
void Update()
{
    if (m_FadeImg == null)
        return;

    FadeUpdate();
}

void FadeUpdate()
{
    if (m_StartFade == false)
        return;

    if(m_CacTime < 1.0f)
    {
        m_AddTimer += Time.deltaTime;
        m_CacTime = m_AddTimer / AniDuring;
        m_Color = m_FadeImg.color;
        m_Color.a = Mathf.Lerp(m_StVal, m_EndVal, m_CacTime);
        m_FadeImg.color = m_Color;

        if(1.0f <= m_CacTime)
        {
            if (m_StVal == 1.0f && m_EndVal == 0.0f) //들어올 때 
            {
                m_Color.a = 0.0f;
                m_FadeImg.color = m_Color;
                m_FadeImg.gameObject.SetActive(false);
                m_StartFade = false;
            }
            else if (m_StVal == 0.0f && m_EndVal == 1.0f) //나갈 때
            {
                SceneManager.LoadScene(m_SceneName);
            }
        }//if(1.0f <= m_CacTime)

    }//if(m_CacTime < 1.0f)
}//void FadeUpdate()

public void SceneOut(string a_ScName)
{
    if (m_FadeImg == null)
        return;

    m_SceneName = a_ScName;

    m_CacTime = 0.0f;
    m_AddTimer = 0.0f;
    m_StVal = 0.0f;
    m_EndVal = 1.0f;
    m_FadeImg.color = new Color32(0, 0, 0, 0);
    m_FadeImg.gameObject.SetActive(true);
    m_StartFade = true;
}

}

#include <iostream>

/** 문자열 관련 라이브러리*/
#include <string>
/** 배열의 사이즈를 알기 위한 라이브러리*/
#include <array>

/** C++ 표준 라이브러리 사용합니다. */
using namespace std;

int main()
{
    /**
   1. 배열과 포인터
   2. 배열포인터
   3. 포인터배열
   */

   /** 1. 배열과 포인터*/
    int intValue1 = 10;
    /** 포인터 변수를 선언하고 초기화를 합니다. */
    int* intPtr1 = &intValue1;

    cout << "intPtr1 : " << *intPtr1 << ", intPtr1 address : " << intPtr1 << endl;

    *intPtr1 = 20;

    cout << "intPtr1 : " << *intPtr1 << ", intPtr1 address : " << intPtr1 << endl;

    cout << endl;
    cout << endl;

    // 주소값을 확인
    // int타입의 무게는 4바이트이다
    // 주소값은 16진수이다.

    // 포인터 변수에 1을 더한 값이 출력된 것을 볼 수 있다
    // intPtr1 + 1의 주소값 : intPtr1의 주소값에 4바이트를 더한 값
    cout << "intPtr1의 주소값 : " << intPtr1 << endl;
    cout << "intPtr1 + 1의 주소값 : " << intPtr1 + 1 << endl;
    cout << endl;
    cout << endl;

    /** 배열을 선언하면 배열의 시작주소(배열의 0번째 인덱스 값의 주소입니다. )가 반환됩니다. */

    /** 문장을 추가해 줍니다. */
    int intArr1[] = { 1, 3, 5, 7, 9, 11, 13, 15, 17 };

    cout << "intArr1[0] value : " << *intArr1 << endl;          // 0번째 인덱스의 값
    cout << "intArr1[0] value : " << intArr1[0] << endl;        // 0번째 인덱스의 값

    cout << "intArr1[1] value : " << *(intArr1 + 1) << endl;    // 1번째 인덱스의 값
    cout << "intArr1[1] value : " << intArr1[1] << endl;        // 1번째 인덱스의 값

    cout << "intArr1[0] address : " << intArr1 << endl;         // 0번째 인덱스의 주소값
    cout << "intArr1[0] address : " << &intArr1[0] << endl;     // 0번째 인덱스의 주소값

    cout << "intArr1[1] address : " << intArr1 + 1 << endl;     // 1번째 인덱스의 주소값
    cout << "intArr1[1] address : " << &intArr1[1] << endl;     // 1번째 인덱스의 주소값

    /** 다음과 같은 표현도 가능합니다. */
    cout << "intArr1[1] address : " << &intArr1[0] + 1 << endl;

    cout << "" << endl;
    cout << "" << endl;

    /**
    반복문으로 주소값을 출력해 봅니다.
    문장을 추가해 줍니다.
    */

    /** foreach문에서 인덱스를 사용해 봅니다. */

    for (int i : intArr1)
    {
        cout << "intArr1[" << i << "] address : " << &intArr1[i] << endl; // 잘못된 값입니다. 
    }
    cout << endl;
    cout << endl;

    int index = 0;

    for (int i : intArr1)
    {
        cout << "intArr1[" << index << "] address : " << &intArr1[index] << endl;
        index++;
    }
    cout << endl;
    cout << endl;

    for (int i = 0; i < size(intArr1); i++)
    {
        cout << "intArr1[" << i << "] address : " << &intArr1[i] << endl;
    }
    cout << endl;
    cout << endl;

    char charValue2 = 'L';
    int intValue2 = 1024;
    double doubleValue2 = 3.14;

    /** 포인터 변수의 사이즈는 4바이트 입니다. 확인해 봅니다. */
    cout << "charValue2 size : " << sizeof(charValue2) << endl;
    cout << "charValue2 ptr size : " << sizeof(&charValue2) << endl;

    cout << "intValue2 size : " << sizeof(intValue2) << endl;
    cout << "intValue2 ptr size : " << sizeof(&intValue2) << endl;

    cout << "doubleValue2 size : " << sizeof(doubleValue2) << endl;
    cout << "doubleValue2 ptr size : " << sizeof(&doubleValue2) << endl;

    cout << endl;
    cout << endl;

    /** 배열의 요소를 출력해 봅니다. */
    int intArr2[9] = { 1, 2, 3, 4,5, 6, 7, 8, 9 };

    for (int i = 0; i < size(intArr2); i++)
    {
        cout << intArr2[i] << " ";
    }
    cout << endl;
    cout << endl;

    for (int i = 0; i < size(intArr2); i++)
    {
        cout << *(intArr2 + i) << " ";
    }
    cout << endl;
    cout << endl;

    for (int* ptr = intArr2; ptr < intArr2 + size(intArr2); ptr++)
    {
        cout << *ptr << " ";
    }
    cout << endl;
    cout << endl;

    /** 배열의 사이즈를 알아보도록 합니다. */
    cout << "array size : " << sizeof intArr2 / sizeof intArr2[0] << endl;      // array size : 9

    cout << "array size : " << size(intArr2) << endl;                           // array size : 9

    cout << "array size : " << sizeof(intArr2) / sizeof(intArr2[0]) << endl;    // array size : 9

}

2. 배열포인터

#include <iostream>

/** 문자열 관련 라이브러리*/
#include <string>
/** 배열의 사이즈를 알아오기 위한 라이브러리*/
#include <array>

/** C++ 표준 라이브러리 사용합니다. */
using namespace std;


int main()
{
    /**
    1. 배열과 포인터
    2. 배열포인터
    3. 포인터배열
    */

    /** 2. 배열포인터*/
    int intArr1[9] = { 1, 2,3, 4, 5, 6, 7, 8, 9 };
    int* intPtr1 = intArr1;

    for (int i = 0; i < size(intArr1); i++)
    {
        cout << *(intPtr1 + i) << " ";
    }
    cout << endl;
    cout << endl;

    for (int i = 0; i < size(intArr1); i++)
    {
        cout << intPtr1[i] << " ";
    }
    cout << endl;
    cout << endl;

    // 3번째 문장이 헷갈립니다. 다음과 같이 이해하면 된다
    // intArr1[i] => *(intArr1 + i) => *(intPtr1 + i) => *(i + intPtr1) => i[intPtr1]
    for (int i = 0; i < size(intArr1); i++)
    {
        cout << i[intPtr1] << " ";
    }
    cout << endl;
    cout << endl;

    /**
    포인터와 배열의 관계에 대해서 정리하기.
    */
    intPtr1 = &intArr1[0];
    cout << "intPtr1 : " << &intArr1[0] << endl;        //intPtr1 : 012FF718

    intPtr1 = &intPtr1[0];
    cout << "intPtr1 : " << &intPtr1[0] << endl;        //intPtr1 : 012FF718

    *intPtr1 = intArr1[0];
    cout << "*intPtr1 : " << intArr1[0] << endl;        //*intPtr1 : 1

    *intPtr1 = intPtr1[0];
    cout << "*intPtr1 : " << intPtr1[0] << endl;        //*intPtr1 : 1

    cout << endl;
    cout << endl;

    /* 그러면 intPtr1 +1 의 값은?*/
    cout << "intPtr1 : " << intPtr1 << endl;
    /** intPtr1 포인터 변수에 sizeof(*intPtr1)을 더한 주소값입니다. */
    cout << "intPtr1 + 1 : " << intPtr1 + 1 << endl;
    cout << endl;
    cout << endl;

    /*반복문으로 주소값 출력하기*/
    for (int i = 0; i< size(intArr1); i++)
    {
        cout << "address : " << &intArr1[i] << endl;
    }
    cout << endl;
    cout << endl;

    /* 배열이 아닌 포인터 주소로 알아보니 에러 발생*/
    // for(int i = 0; i < size(intPtr1); i++)
    // {

    // }

    /** double 타입으로 테스트를 해 봅니다.*/
    double doubleValue1[5] = { 3.14, 3.14, 3.14, 3.14, 3.14 };

    for (int i = 0; i < size(doubleValue1); i++)
    {
        cout << "double address : " << &doubleValue1[i] << endl;
    }

    cout << endl;
    cout << endl;

    cout << "size of double : " << sizeof(doubleValue1[0]) << endl;

    cout << endl;
    cout << endl;

    /** string 타입으로 테스트를 해 보도록 합니다.*/
    string stringValue1[] = { "Jane", "Tom", "James", "Emma", "Smith" };

    for (int i = 0; i < size(stringValue1); i++)
    {
        cout << "string address : " << &stringValue1[i] << endl;
    }
    cout << endl;
    cout << endl;

    cout << "size of string : " << sizeof(stringValue1[0]) << endl;

    cout << "size of string address : " << sizeof(&stringValue1[0]) << endl;

    cout << endl;
    cout << endl;

    /**
    배열포인터에 대해서 알아 봅니다.
    배열포인터는 배열 자체를 가리키는 포인터 입니다.
    */
    int intArr3[3] = { 1, 2, 3 };
    /** 사이즈가 3인 int타입의 배열을 가리키는 포인터를 선언합니다. */
    int(*arrPtr3)[3];

    arrPtr3 = &intArr3;

    /** 반복문으로 값 출력하기 */
    for (int i = 0; i < size(intArr3); i++)
    {
        /**
        배열포인터가 가리키는 값은 배열입니다.
        (arrPtr3) : 배열포인터입니다.
        *(arrPtr3) : 배열포인터가 가리키는 값은 배열입니다.
        (*arrPtr3)[i] : 배열에 인덱스로 접근합니다.
        */
        cout << "*(arrPtr3)[" << i << "] : " << (*arrPtr3)[i] << endl;
    }
    cout << endl;
    cout << endl;

    // 문장 추가
    int intArr4[5] = { 1, 2, 3, 4, 5 };
    /** int타입의 요소를 5개 가지고 있는 배열을 가리키는 배열포인터를 선언합니다. */
    int(*arrPtr4)[5];

    arrPtr4 = &intArr4;

    cout << "size of intArr4 : " << sizeof(intArr4) << endl;
    cout << endl;
    cout << endl;

    for (int i = 0; i < size(intArr4); i++)
    {
        cout << "intArr4[" << i << "] 주소값 : " << *arrPtr4 + i << endl;
    }
    cout << endl;
    cout << endl;

    for (int i = 0; i < size(intArr4); i++)
    {
        cout << "intArr4[" << i << "] 값 : " << (*arrPtr4)[i] << endl;
    }
    cout << endl;
    cout << endl;
}

3. 포인터배열

#include <iostream>

/** 문자열 관련 라이브러리*/
#include <string>
/** 배열의 사이즈를 알기 위한 라이브러리*/
#include <array>

/** C++ 표준 라이브러리 사용합니다. */
using namespace std;

int main()
{
    /**
    1. 배열과 포인터
    2. 배열포인터
    3. 포인터배열

    포인터배열을 자세하게 알기 위해서는 이중 for문, 2차원 배열의 지식이 필요합니다.
    */

    /** 3. 포인터배열*/

    // 구구단 
    for (int i = 2; i <= 9; i++)
    {
        for(int j = 1; j <=9; j++)
        {
            cout << i << " * " << j << " = " << i * j << endl;
        }
        cout << endl;

    }
    cout << endl;
    cout << endl;

    /**
    Row : 행, Column : 열

    세로 크기(행)가 3이고 가로 크기(열)이 4인 int타입의 2차원 배열을 선언합니다.
    */
    int numArr[3][4] =
    {
        {11, 22, 33, 44},
        {55, 66, 77, 88},
        {99, 110, 121, 132}
    };

    // 11 : 세로 인덱스 0, 가로 인덱스 0인 요소 출력
    cout << "numArr[0][0] : " << numArr[0][0] << endl;
    // 77 : 세로 인덱스 1, 가로 인덱스 2인 요소 출력
    cout << "numArr[1][2] : " << numArr[1][2] << endl;
    // 99 : 세로 인덱스 2, 가로 인덱스 0인 요소 출력
    cout << "numArr[2][0] : " << numArr[2][0] << endl;
    // 132 : 세로 인덱스 2, 가로 인덱스 2인 요소 출력
    cout << "numArr[2][3] : " << numArr[2][3] << endl;
    cout << endl;
    cout << endl;

    /* 
    행을 구하는 공식
    현재 2차원 배열의 행( 세로 크기 )의 사이즈는 3이다
    2차원 배열의 세로 크기를 구할 때는
    배열이 차지하는 전체 공간을 가로 한 줄의 크기로 나눠 준다.
    */
    int row = sizeof(numArr) / sizeof(numArr[0]);
    cout << "row : " << row << endl;
    cout << endl;

    /*
    열을 구하는 공식
    현재 2차원 배열의 열( 가로 크기 )의 사이즈는 4이다
    2차원 배열의 가로 크기를 구할 때는
    가로 한 줄의 크기를 요소의 크기로 나눠 준다
    */
    int col = sizeof(numArr[0]) / sizeof(int);
    cout << "col : " << col << endl;
    cout << endl;

    /**
    반복문으로 2차원 배열의 요소들을 출력하기.
    세로 크기와 가로 크기를 이미 구해 놓았다.
    반복문으로 세로부터 반복한 뒤, 가로를 반복하면서 2차원 배열의 요소를 출력한다.
    */

    // 2차원 배열의 세로 크기만큼 반복
    for (int i = 0; i < row; i++)
    {
        // 2차원 배열의 가로 크기만큼 반복
        for (int j = 0; j < col; j++)
        {
            // 반복문의 지역변수 i와 증감문으로 1씩 증가하므로 
            // 2차원 배열의 세로 인덱스에는 i의 값을
            // 2차원 배열의 가로 인덱스에는 j의 값을 넣으면
            // 배열의 요소를 순서대로 접근할 수 있다.
            cout << numArr[i][j] << " ";
        }
        // 가로 요소를 출력한 뒤에 다음 줄로 넘어감
        cout << endl;

    }
    cout << endl;
    cout << endl;

    /** 포인터배열은 배열 하나가 아닌 여러개의 배열을 한번에 처리할 수 있는 엄청난 효율이 있다. */

    /**
    2차원 배열의 요소들을 역순으로 출력하기.
    이미 세로 사이즈(행), 가로 사이즈(열)은 미리 구해 놓았다.
    반복문의 초기값에 배열의 세로 크기와 가로 크기를 바로 넣어 버리면
    처음부터 배열의 인덱스를 벗어난 상태가 된다.
    배열의 인덱스는 0부터 시작하기 때문이다.
    따라서 마지막 요소의 인덱스는 요소의 개수에서 1을 빼준다.
    그리고 0까지 반복할 수 있도록 조건식을 i >= 0와 같이 해 준다.
    */

    // 세로 크기 - 1 부터 역순으로 반복
    for (int i = row - 1; i >= 0; i--)
    {
        // 가로 크기 - 1 부터 역순으로 반복
        for (int j = col - 1; j >= 0; j--)
        {
            // 2차원 배열의 인덱스에 반복문의 변수 i, j를 지정
            cout << numArr[i][j] << " ";
        }
        //가로 요소를 출력한 뒤에 다음 줄로 넘어갑니다.
        cout << endl;

    }
    cout << endl;
    cout << endl;

    /** 포인터배열 : 포인터들을 배열에 저장. */
    int num1 = 100;
    int num2 = 200;
    int num3 = 300;

    int intArr1[3] = { num1, num2, num3 };

    for (int i = 0; i < size(intArr1); i++)
    {
        cout << "address : " << &intArr1[i] << ", value : " << intArr1[i] << endl;
    }

    cout << endl;
    cout << endl;

    /* 포인터배열은 틀리다.*/
    int* arr[3] = { &num1, &num2, &num3 };

    for (int i = 0; i < size(arr); i++)
    {
        cout << "address : " << arr[i] << ", value : " << *arr[i] << endl;
    }
    cout << endl;
    cout << endl;

    /**
   1. 2차원 배열에 배열들의 요소들을 출력해 보았다.
   2. 정수값을 포인터배열에 저장해서 요소들을 출력해 보았다.
   3. 포인터배열의 장점은 하나가 아닌 여러개의 배열을 한번에 처리할 수 있는 장점이 있다.

    배열을 포인터배열에 저장해서 요소들을 출력하기.
   */

   /**
   2차원 배열에서는 세로 크기와 가로 크기가 동일했다.
   각각의 배열들의 사이즈가 클리더라도 포인터배열은 배열을 저장하는 것이고
   배열의 포인터를 저장하는 것이라 배열들의 사이즈가 틀리더라도 가능하다.
   */
    int intArr2[5] = { 1, 2, 3, 4, 5 };
    int intArr3[6] = { 10, 20, 30, 40, 50, 60 };
    int intArr4[7] = { 100, 200, 300, 400, 500, 600, 700 };

    /**
    포인터배열을 선언하고 각각의 주소값을 대입해 준다.
    배열의 이름은 배열의 시작주소(배열의 0번째 인덱스 값의 주소)이므로 배열이름으로
    주소값을 대입한 것과 동일하다.
    */
    int* ptrArr[3] = { intArr2, intArr3, intArr4 };

    /**
    세로 사이즈(행)를 구하기.
    세로 사이즈는 3이다.
    */
    int length = size(ptrArr);

    /**
    가로 사이즈(열)를 구하기.
    배열의 사이즈가 틀리니 가로 사이즈는 배열로 만들어 준다.
    가로 사이즈는 배열 {5, 6, 7} 이다.
    */
    int subLength[3] = { size(intArr2), size(intArr3), size(intArr4) };

    /** 포인터배열의 세로 사이즈만큼 반복. */
    for (int i = 0; i < length; i++)
    {
        /**
        포인터배열의 가로 사이즈만큼 반복.
        가로 사이즈는 배열 크기가 모두 달라서 subLength배열에서 인덱스로 접근합니다.
        */
        for (int j = 0; j < subLength[i]; j++)
        {
            /** 포인터 배열의 인덱스에 반복문의 i와 j를 지정합니다. */
            cout << ptrArr[i][j] << " ";
        }
        /** 가로 요소를 출력한 뒤에 다음 줄로 넘어갑니다. */
        cout << endl;
    }
    cout << endl;
    cout << endl;

    /** 문자열로 된 배열을 포인터배열에 추가해 줍니다. */
    string names[5] = { "Tom", "John", "Jane", "Smith", "James" };
    string nations[3] = { "Korea", "Japan", "China" };
    string animals[6] = { "Tiger", "Lion", "Dog", "Cat", "Ang", "Pig" };

    /**
    포인터배열에 각각의 주소값을 대입합니다.
    배열의 이름은 배열의 시작주소(배열의 0번째 인덱스 값의 주소)입니다.
    */
    string* ptrArr1[3] = { names, nations, animals };

    /** 세로 사이즈(행, Row)를 구합니다. */
    int strLength = size(ptrArr1);

    /**
    가로 사이즈(열, Column)를 구합니다.
    배열들의 사이즈들이 모두 틀려서 배열에서 가로 사이즈를 구합니다.
    */
    int strSubLength[3] = { size(names), size(nations), size(animals) };

    /** 포인터배열의 가로 사이즈만큼 반복합니다. */
    for (int i = 0; i < strLength; i++)
    {
        /** 포인터배열의 세로 사이즈만큼 반복합니다. */
        for (int j = 0; j < strSubLength[i]; j++)
        {
            /**
            반복문의 변수 i와 j는 증감문을 통해서 1씩 증가하므로 포인터배열의 세로 인덱스에는 i의 값을
            포인터배열의 가로 인덱스에는 j의 값을 넣으면 포인터배열의 요소를 순서대로 접근할 수 있습니다
            */
            cout << ptrArr1[i][j] << " ";
        }
        /** 가로 요소를 출력한 뒤에 다음 줄로 넘어값니다. */
        cout << endl;
    }
    cout << endl;
    cout << endl;

}

게임의 최적화기술을 한장의글로 서술하기엔 말도안되지만 범용적이고 적용하기쉬운 또 VR에서 효과적인 부분들을 추려서 소개해보겠습니다. 이미 최적화에대한 기본기와 게임개발의 노하우가 있으신분들은 너무쉬운 내용일수 있기때문에 굳이 보지않으셔도 됩니다.

마찬가지로 이번글역시 단순한 팁 그이상그이하도 아니므로 본인의 컨텐츠에 필요한 부분만 습득하시길 바랍니다.

=======================================================================================

개발기술편-2

1. 90프레임의 중요성

VR게임은 PC의 하드웨어성능을 공유하더라도 일반적인 게임렌더링보다 당연하게도 더높은 자원을 소비합니다. 왜냐하면 헤드트래킹을 이용한 양안에 렌더링을 해야하기때문에 두배또는 그이상의 자원이 요구되기 때문입니다. 따라서 일반 PC나 콘솔처럼 개발한다면 VR플레이를 눌렀을때 프레임이 곤두박질치는 낭패를 볼수있습니다. 또한 VR개발시 가장힘든부분이 90프레임을 유지하는것입니다. 90프레임이란 수치는 일반적인 VR기기에서 낼수있는 가장높은 프레임입니다. 만약 이수치보다 프레임이 저하된다면 플레이어의 멀미와 눈의피로도가 현저하게 올라가서 컨텐츠가 망하기 가장쉬운 길입니다. 그렇기때문에 90프레임을 유지하는것이 VR컨텐츠의 가장기본이고 멀미를 줄이는 최고의방법입니다. VR에선 아무리 컨텐츠를 멋지고 화려하게 만들어봤자 프레임이 안나오는 순간 그것은 멀미유발제일 뿐입니다.

2. 게임도중 로딩은 최악의수. 프리(pre)로딩의 중요성

앞서말했듯이 프레임간의 간격과 딜레이 괴리감이 멀미와 몰입도에 엄청난 영향을 줍니다. 일반적인 게임은 '디스플레이'라는 공간안에서 벌어지는 가상세계라는것을 플레이어가 인지하고 게임을 진행합니다. 그러나 VR은 인지조화가 현실세계처럼 일어나는 공간이라 인간의 지각이 가상세계임을 인지하기 어렵습니다. 따라서 내가인지하고있는 시각의 간극이 현실세계와다르게 끊기거나 딜레이가 발생한다면 그순간 멀미가 발생하고 몰입도가 깨져버립니다. 따라서 맵을 이동하거나 대량의 오브젝트가 스폰됬을때 등등 발생하는 로딩의 순간들이 일반적인 컨텐츠에서는 당연할수있지만 VR컨텐츠에서는 매우 금기시되는 일입니다.

따라서 레벨스트리밍이나 오픈레벨같은 함수들을 사용하는것은 굉장히 위험한 일입니다. 일반적인 게임의 대표적 최적화 기술인 레벨스트리밍 조차 잠깐의 화면끊김시간을 유발할수 있습니다. 특히 오픈레벨은 정말 긴시간의 로딩을 유발할수도있습니다. 그렇다면 이런것들을 어떻게 극복할수 있을까?

1) 오픈레벨을 최소화, 비밀의방을 만들자.

비밀의방이란 단어는 약간의 은어인데 제가 회사에서 개발하던시절 쓰던 용어입니다. 일반적인 게임의 진행은 [메뉴창,설정,난이도......등등 UI셋팅레벨] - [게임진행레벨] 이런식으로 구성됩니다. 이때 두개의 레벨로 나뉘어져있기때문에 레벨간 이동을할때 로딩시간이 발생합니다.

VR에선 로딩시간이 발생되면 안되기때문에 이러한것들을 하나의 레벨안에 전부 구성합니다. 그러면 한레벨안에 많은 로딩이 발생하기 때문에 시작이 오래 걸릴수는 있지만 도중에 끊기는 현상은 막을수있습니다.

쉽게말하면 처음시작할때 대부분의 로딩을 시키고 플레이도중에는 로딩을최소화 하는것입니다. 그렇기에 처음게임을 시작할때 등장하는 셋팅화면,메뉴화면등을 같은레벨안의 다른 '비밀의방'을 만들어둔뒤 진행합니다. 그렇게되면 이미 로딩된 게임공간으로 이동시간을 최소화 시킬 수 있습니다.

이런식으로 게임의 처음 시작뿐만이아니라 인게임도중 장소나 환경을 바꿀일이 있다면 다음과 같은 방법을 사용하는것이 효휼적일 수 있습니다.

2) 화면전환시 자연스러운 트랜지션효과는 필수.

아무리 프리로딩을 해서 진행한다해도 순식간에 주변환경이바뀌는 것은 멀미를 유발할수 있습니다. 따라서 화면을 전환할때는 적절한 효과가 필수입니다. 진행상황에 따라 일반적으로 쓰이는 블랙아웃이나 화이트아웃 또는 디졸브 같은 효과로 최대한 자연스럽게 화면을 전환해야 멀미를 최소화 할 수 있습니다.

3. 쉐이더는최대한 간단하게.

VR에선 화질이 그렇게 좋지않습니다. 모니터와는 다르게 받아들이는 시각정보가 뚜렷하게 보이지않기때문에 셰이더에 너무 집착할필요가없습니다. 셰이더는 최대한 간단하게 해야하며 화려한 PBR메터리얼을 만드는것은 자칫하면 낭비일수도 있습니다. 간단한 텍스쳐 몇장으로 좋은 퀄리티를 뽑아야합니다. 특히나 복잡한 수식으로 구현한 셰이더는 쓸데없는 낭비일뿐입니다. 왠만하면 최종 텍스쳐를 베이크해서 수식을줄이고 최적화하는것이 좋습니다. 절대로 언리얼예제에있는 파티클이펙트 예제나 다른 예제의 엄청난 셰이더를 VR에 적용하려고하지마세요. 용도가 분명히 다릅니다! 또한 구매한 에셋들을 이주시키는 경우가 많이 있는데 대부분 VR에 최적화된 에셋들이아닌경우가 다반사입니다. 반드시 프로젝트에 맞춰서 한번더 최적화를 하고 이주해야합니다.

4.동적라이트는 심사숙고 해야한다.

프로젝트가 정말정말 가볍지않은이상 동적라이트는 매우 위험할수있습니다. 사실 최적화부분에서 초보자가 가장 하기 쉽고 효과적인것이 스태틱라이트로 전환하는것입니다. 물론 다이나믹섀도우는 기대하기어렵지만 페이크섀도우를 최대한 활용하여 섀도우를 동적으로 그려주는것이 좋습니다. 물론 최적화에 굉장한 자신이 있다면 다이나믹라이트도 도전해볼만하지만 그렇지않고 시간적,인적 자원이 부족하다면 스태틱라이트는 최선의 선택일것입니다.

5.BP or C++?

다들아시겠지만 성능이야 cpp 를 BP가 이길수가 없습니다. 그러나 VR게임의 특성을 생각해보면 때론 BP로 만드는것이 더 효휼적일수 있습니다. 대부분 VR게임이 MMO처럼 대규모 멀티플레잉을 요구하거나 큰데이터를 처리하는 컨텐츠는 많이없습니다. 간단한 체험물이거나 싱글게임처럼 복잡한 알고리즘을 사용할 일이 거의없는 컨텐츠들도 많습니다. 물론 시간이 충분하고 인적자원도 충분하다면 CPP로 짜는게 백번천번 좋지만 그렇지않고 1회성컨텐츠거나 사후관리가 거의필요없거나 패치등도 할일이 거의없다면 BP를 많이 활용하는것이 좋을수도있습니다. BP의 가장큰 장점은 제작속도입니다. 사실 규모가 작은 프로젝트는 BP로 짜던 CPP로짜던 성능차이가 매우 적을수있습니다. 그렇기에 BP로 빠르게 시스템설계를하고 그래픽쪽 최적화에 투자하는것이 훨씬 효휼적인경우가 많이있습니다. 이것은 설계부분에서 결정해야할 문제기때문에 프로그래머는 프로젝트의 규모와 시스템을 시작단계에서 잘계획하여 제작한다면 시간을 굉장히 아낄수 있습니다. 때론 작은프로젝트에선 알고리즘이나 코드로 최적화하기보단 폴리곤수 한개라도 더 줄이는게 효과적일수 있기 때문입니다.

6.90프레임의 틈을 노려보자

가장 처음에 강조했지만 VR게임에서 90프레임이 얼마나 중요한지에대해 말씀드렸습니다. 그러나 90프레임을 무조건 유지하지않아도 되는경우가 있는데 아무것도 움직이지 않을때입니다. 특히 UI만 보고있을때나 영상같은것을 보고있을때는 움직임이 없기때문에 90프레임 이하로 떨어져도 크게상관이 없습니다. 90프레임이 정안된다면 이러한 부분들은 포기하고 넘어가도 크게상관없습니다.

7. 렌더타겟은 정말 무겁다.

거울을 만들거나 CCTV등 어떤 특정장면을 보여줘야할때 쓰이는 렌더타겟은 정말정말 무겁습니다. 따라서 어떤 장면을 보여줘야할 상황이온다면 그냥 영상으로 녹화한다음 미디어컨텐츠로 영상으로 보여주는것이 훨씬더 가볍습니다.

8. 대표적으로 무거워서 쓰기어려운것들.

위에 언급한것 이외에 테셀레이션,데칼,모든종류의 블러(PP의 뎁스오브필드 포함) 파티클안에 라이트(진짜 무겁다), 많은수의 파티클 이펙트(파티클은 최소화해야한다) -> 특히 파티클은 에셋구매할경우가많은데 에셋들은 멋있게 보이게 하기위해 라이트모듈을 넣은경우가많다. 반드시 체크해보자! [출처] [효율적인 VR컨텐츠 개발하기] [개발기술편-2] (언리얼 엔진 공식 카페 (Unreal Engine)) | 작성자 포인팅