KiTFOx's Notepad 📝

언리얼 공부를 처음 하다보니 인프런에서 강의를 찾아봤음에도 5.1 -> 5.2로 엔진을 변경하고 나니 갑자기 같은 코드라 해도 버그가 뜨더라..

디버그 해서 타고타고 찾아보니 GetWorld() 가 null을 반환하는 문제였는데 뭐가 문제인지 몰라서 받아오는게 문제인가.. 내가 찾아본게 맞나..하고 있었다.

하지만 그 와중에 굉장한 도움을 주신.. 중국 사이트분 감사합니다..

https://blog.csdn.net/qq_31930499/article/details/88365717

결론적으로는 GetWorld() 앞에 GWorld->GetGameInstance()를 붙여주니 동작이 잘된다.

최적화적인 측면에서 좋은지 안좋은지는 모르겠지만 그부분은 좀 더 찾아봐야할듯하다.

나처럼 처음 언리얼을 만지는 사람들에게 도움이 되길 바라며ㅠㅠ

원문: https://benui.ca/unreal/ui-cpp-basics/

Unreal을 위한 많은 UI 튜토리얼은 Blueprint에 초점을 맞추고 있습니다. 이것은 더 넓은 매력을 가질 수 있지만 전문가 수준의 UI를 만들려면 C++을 사용해야 합니다.

왜 우리는 C++을 사용해야 하는가?

우선, 분명히 우리는 Blueprint로 모든 것을 할 수 있는데, 왜 우리는 C++로 UI를 만들어야 하나요? 라는 질문을 할 수 있습니다. 그것은 맞을수도 있지만 아닐수도 있습니다. Blueprint를 사용하여 전체 게임의 UI를 작성할 수 있지만 그 과정에서 몇 가지 주요 문제에 부딪힐 것입니다.

• Blueprint 기반의 대형 UI에서 성능 문제에 부딪힐 가능성이 높습니다. 작은 1회용 Blueprint는 괜찮지만 모든 프레임으로 불리는 크고 복잡한 로직의 경우 Blueprint 기반의 UI가 실제로 성능에 영향을 미칠 수 있습니다.
• Blueprint에서 복잡한 논리는 악몽을 계속 유지시킵니다. 큰 Blueprint 스크립트를 작성한 사람은 스파게티 코드에 대한 끊임없는 싸움의 원인이 될 것 입니다.
• 수집, 처리 및 데이터 프레젠테이션을 분리할 필요가 없습니다. Blueprint 전용 시스템을 사용하면 서로 다른 소스에서 데이터를 가져오는 것과 표시를 위해 포맷화하는 것을 쉽게 혼합할 수 있습니다. 이것은 디스플레이 그래프 노드가 데이터 수집 노드와 매우 밀접하게 연결되어 있기 때문에 향후 데이터를 변경하거나 구현해야 할 때 실질적인 어려움을 야기합니다.
• 많은 사람들이 한 번에 UI 작업을 하기가 더 어렵습니다. Blueprint는 이진 자산으로 병합이 불가능하므로 한번에 한 사람만 편집할 수 있습니다. UI 아티스트가 위젯의 모양을 업데이트하고 개발자가 Blueprint 로직을 업데이트하려면 아티스트가 기다려야 합니다. 대부분의 로직이 C++이면 두 사람 모두 서로의 발가락을 밟을 가능성이 낮습니다.

C++을 사용한 UI를 만드는 세가지 방법

여기서 일이 조금 까다로워집니다. 모든 UI 디자인과 마찬가지로 동일한 작업을 수행하는 100가지 방법이 있습니다. 이 세 가지 접근 방식은 다음 튜토리얼에서 개별적으로 다루겠지만 대략 다음과 같습니다

• UUserWidget 의 Subclassing(다른 클래스의 코드를 재사용할 목적으로 상속을 사용하는 경우)
• Subclassing 혹은 새로운 UMG 위젯 생성
• Subclassing 혹은 새로은 Slate 위젯 생성

이것들은 각각 장점과 단점이 있습니다. 이것들이 의마하는 바를 알기 위해서는 Slate와 UMG의 차이점에 대해 얘기해야 합니다.

Slate와 UMG

첫 번째 C++ 기반 UserWidget을 만들려면 UUserWidget의 하위 클래스인 C++ 클래스를 만들어야 합니다.

이 작업을 시작하기 전에 이제 편집기에서 UI를 만들고 팔레트에 있는 대부분의 위젯의 목적과 기능을 이해해야 합니다. 이는 에디터와 블루프린트를 사용하여 간단한 UI를 생성해봄으로써 가장 빠르게 이해할 수 있습니다. 그 방법은 시리즈 소개를 참조하십시오.

다음 단계는 C++에서 위젯을 만드는 방법을 배우는 것입니다.

이번 시리즈의 서론에서 언급했듯이 Unreal(4.15 기준)에는 UMG와 Slate 두 가지 UI 시스템이 있습니다.

Slate는 오래된 Unreal UI 시스템이고, UMG와 에디터가 기반을 두고 있습니다. 위젯 설정을 단순화하기 위해 고전적인 외관의 C++을 사용합니다. "오래된" 시스템이라고 해서 오래된 것은 아니라는 것을 이해하는 것이 중요합니다. UI에 더 복잡한 기능을 추가하기 위해 슬레이트를 점차 배워야 할 것입니다.

UMG는 Unreal 4의 일부로 추가된 새로운 UI 시스템입니다. Blueprint 친화적으로 설계되었으며 디자이너가 편집기에서 UI를 시각적으로 배치할 수 있습니다. 각 UMG 위젯은 일반적으로 거의 동일한 이름의 Slate 클래스를 내부에 가지고 있습니다. **Slate 클래스는 대부분의 로직을 처기하고 해당 UMG 클래스는 그것을 감싸는 wrapper입니다. 예를 들어 UImage는 UMG 클래스이며 내부에 SImage 인스턴스를 포함합니다.

먼저, 역사의 작은 부분입니다. 이것을 넘어가지 마세요. 여러분의 이해를 위해 중요합니다!

4.0 버전 이전에는 Unreal의 UI가 Slate라는 시스템을 사용하여 만들어졌습니다. 가능한 한 간단하게 C++의 UI를 만들 수 있도록 설계되었습니다. 나중에 튜토리얼 시리즈에서 여러분도 어떻게 사용할 수 있는지 설명하겠습니다.

언리얼 엔진 4.0 버전으로 에픽은 그들의 새로운 UI 시스템인 UMG를 출시했습니다. UMG는 효과적으로 Slate를 감싸는 wrapper 이고, Blueprints에서 더 쉽게 사용할 수 있도록 하고 UI 디자이너가 언리얼 에디터 내에서 사용자 정의 UI를 만들 수 있도록 합니다.

Slate가 논의할 모든 UMG시스템의 기초가 된다는 것을 이해하는 것이 중요합니다. 슬롯, 다양한 위젯, 위젯에 대한 옵션 등은 Slate와 모두 동일합니다. UMG는 Slate를 위한 에디터 및 Blueprint에 적합한 wrapper일 뿐입니다.

세 가지 접근방법

이 방법에서 벗어나 UI에 C++ 기반 위젯을 추가할 수 있는 방법은 크게 세 가지입니다. 아래에 나열된 것은 점진적으로 낮은 수준의 '더 많은 작업'이며, 그 중 어느 것도 문제를 해결할 수 있는 유일한 '최상의 방법'은 아니며, 각각의 접근 방식에는 각각의 장점과 단점이 있습니다.

맥락상, 여러 해 동안 Unreal UI 프로그래머로 일한 경험은 다음과 같습니다.

• 커스텀 UUserWidget - 95%의 경우 이것으로 충분함
• 커스텀 UMG/Slate subclass - 5%의 경우 (매우 특정한 것을 원할 경우 사용자 정의 UMG/Slate 서브 클래스를 만듬)

모든 것이 그렇듯이, 각 접근 방식에도 장단점이 있습니다. 하지만 일반적으로 계층 구조에서 Slate로 갈수록, 더 많은 사용자 정의를 수행할 수 있지만, Blueprints로 인터페이스를 설정하는 작업이 더 많아질 수 있습니다.

각 접근 방식을 각각의 튜토리얼로 분리했습니다.

1. 문제

전체 학생의 수 n,

체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 

여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때,

 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.

2. 코드

#include <string>
#include <vector>
#include <iostream>

using namespace std;

//n : 전체 학생의 수
//lost : 체육복을 도난당한 학생들의 번호 배열
//reserve : 여벌의 체육복을 가져온 학생들의 번호 배열
int solution(int n, vector<int> lost, vector<int> reserve) {
    int answer = 0;
    
    //앞 뒤 수를 비교할 것이기 때문에 정렬 과정이 꼭 필요함
    sort(lost.begin(),lost.end());
    sort(reserve.begin(),reserve.end());
    
    //두가지 배열을 통해 벡터의 삽입,삭제를 진행하지 않고
    //체크를 했는지 표시해줌
    bool isChecked[31]={false};
    bool isCheckedReserve[31]={false};
    int coverNum=0;
    
    //먼저 같은 값들은 모두 true로 변경하고 빌려줌으로써 메꿀수 있는 사람수를 증가
    for(int i=0;i<reserve.size();i++)
    {
        for(int j=0;j<lost.size();j++){
            if(reserve[i]==lost[j]){
                isChecked[j]=true;
                isCheckedReserve[i]=true;
                coverNum++;
            }
        }
    }
    //그 후 남은 것들을 이용하여 앞뒤의 경우의 수를 통해 메꿀수 있는 학생 수 계산
    for(int i=0;i<reserve.size();i++){
        if(coverNum==lost.size())break;
        for(int j=0;j<lost.size();j++){
            if(isChecked[j]||isCheckedReserve[i]) continue;
            else if(lost[j]-1==reserve[i]||lost[j]+1==reserve[i])
            {
                coverNum++;
                isChecked[j]=true;
                isCheckedReserve[i]=true;
            }
        }
    }
    
    //정답 = 총학생수 - 잃어버린 체육복 수 + 메꾼 학생 수
    answer = n-lost.size()+coverNum;
    
    return answer;
}

3. 해설

//n : 전체 학생의 수
//lost : 체육복을 도난당한 학생들의 번호 배열
//reserve : 여벌의 체육복을 가져온 학생들의 번호 배열
int solution(int n, vector<int> lost, vector<int> reserve) {
    int answer = 0;
    
    //앞 뒤 수를 비교할 것이기 때문에 정렬 과정이 꼭 필요함
    sort(lost.begin(),lost.end());
    sort(reserve.begin(),reserve.end());

먼저 경우의 수에서 예외 사항을 제외하기 위해 정렬을 진행해준다. 잃어버린 사람들과 여벌의 체육복을 가지고 있는 사람들의 배열을 정렬을 진행한다.

    //두가지 배열을 통해 벡터의 삽입,삭제를 진행하지 않고
    //체크를 했는지 표시해줌
    bool isChecked[31]={false};
    bool isCheckedReserve[31]={false};
    int coverNum=0;
    
    //먼저 같은 값들은 모두 true로 변경하고 빌려줌으로써 메꿀수 있는 사람수를 증가
    for(int i=0;i<reserve.size();i++)
    {
        for(int j=0;j<lost.size();j++){
            if(reserve[i]==lost[j]){
                isChecked[j]=true;
                isCheckedReserve[i]=true;
                coverNum++;
            }
        }
    }

각각 체크를 했는지 안했는지 기록할 배열 두개를 준비한다. 만약 여벌을 이미 빌려주고, 대여 받은 사람의 경우 체크할 필요가 없기 때문이다.

맨 처음 여벌을 준비한 학생이 잃어버렸을 경우를 체크해준다. (reserve[i]==lost[j]) 이 경우

    //그 후 남은 것들을 이용하여 앞뒤의 경우의 수를 통해 메꿀수 있는 학생 수 계산
    for(int i=0;i<reserve.size();i++){
        if(coverNum==lost.size())break;
        for(int j=0;j<lost.size();j++){
            if(isChecked[j]||isCheckedReserve[i]) continue;
            else if(lost[j]-1==reserve[i]||lost[j]+1==reserve[i])
            {
                coverNum++;
                isChecked[j]=true;
                isCheckedReserve[i]=true;
            }
        }
    }
    
    //정답 = 총학생수 - 잃어버린 체육복 수 + 메꾼 학생 수
    answer = n-lost.size()+coverNum;
    
    return answer;
}

그 후 체크하지 않은 값들을 다시 체크해준다. 이 경우 여벌을 가지고 있는 학생의 id번호 앞뒤인지 아닌지를 체크해주면서 만약 여벌을 빌려주면 coverNum의 값을 높여준다. 이때 coverNum은 말그대로 얼만큼 잃어버린 학생들의 공백을 메꿀수 있는지 나타내는 변수이다.

따라서 정답은 총학생수에 잃어버린 체육복 수를 빼고 메꾼 학생 수를 더해주면 된다.

1. 문제

사전에 알파벳 모음 'A', 'E', 'I', 'O', 'U'만을 사용하여 만들 수 있는, 길이 5 이하의 모든 단어가 수록되어 있습니다. 사전에서 첫 번째 단어는 "A"이고, 그다음은 "AA"이며, 마지막 단어는 "UUUUU"입니다.

단어 하나 word가 매개변수로 주어질 때, 이 단어가 사전에서 몇 번째 단어인지 return 하도록 solution 함수를 완성해주세요.

2. 코드

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<string> nums;
string aeiou[5]={"A","E","I","O","U"};

void repeatPermutation(string s, int maxLength)
{
    if(maxLength==s.size()) //문자열의 크기 == 채울 문자열 크기
    {
        nums.push_back(s);
        return; //재귀함수 종료
    }
    
    for(int i=0;i<5;i++){
        repeatPermutation(s+aeiou[i],maxLength); //재귀함수 호출
    }
}

int solution(string word) {
    int answer = 0;
    
    for(int i=1;i<=5;i++){
        repeatPermutation("",i);
    }
    
    sort(nums.begin(), nums.end());  

    for(int i=0;i<nums.size();i++){
        if(word==nums[i]){
            answer=i;
            break;
        }
    }
       
    return answer+1;
}

3. 해설

vector<string> nums;
string aeiou[5]={"A","E","I","O","U"};

void repeatPermutation(string s, int maxLength)
{
    if(maxLength==s.size()) //문자열의 크기 == 채울 문자열 크기
    {
        nums.push_back(s);
        return; //재귀함수 종료
    }
    
    for(int i=0;i<5;i++){
        repeatPermutation(s+aeiou[i],maxLength); //재귀함수 호출
    }
}

int solution(string word) {
    int answer = 0;
    
    for(int i=1;i<=5;i++){
        repeatPermutation("",i);
    }

재귀 함수를 통해서 모든 경우의 수를 저장합니다.

경우의 수는 1자리일 때, 2자리일 때, 3자리일 때, 4자리일 때, 5자리일 때 모든 경우의 수를 구해야합니다.

따라서 1자리의 경우

for(int i=0;i<5;i++){
        repeatPermutation(s+aeiou[i],maxLength); //재귀함수 호출
}

이 부분이 aeiou[0] ~aeiou[4] 까지의 값이 한번씩 호출 되면서 끝납니다.

2자리의 경우 위의 for문이 aeiou[0]+aeiou[0]~aeiou[4] 에서부터 aeiou[4]+aeiou[0]~aeiou[4] 까지 계산함으로 총 25가지의 문자열이 저장됩니다.

이와 같은 방법으로 5자리의 경우까지 재귀함수를 통해 저장합니다. 

sort(nums.begin(), nums.end());  

    for(int i=0;i<nums.size();i++){
        if(word==nums[i]){
            answer=i;
            break;
        }
    }
       
    return answer+1;
}

그 후, 사전적 배열로 나열해줘야합니다.

기존에 저장된 배열은 A,E,I,O,U,AA,AE,AI,AO,AU.... 등의 순서로 구성되어 있습니다.(함수 호출 순서에 따라 달라질 수 있으나 (1자리수...2자리수...3자리수.... 로 저장)

기본적으로 sort 함수는 string 변수에서 사전적 순서로 정렬해주기 때문에 별도의 판별 함수를 넣지 않아도 됩니다.

그 후 for문을 통해 받은 word 값과 nums[i]의 값이 같다면 해당 번호를 뽑아냅니다.

벡터는 0번부터 시작하기에 +1을 해주면 몇번째 수인지를 도출할 수 있습니다.

※ for문을 쓰지 않고 find() 함수를 통해서 한줄로 해결할 수도 있습니다.

1. 문제

출처:https://school.programmers.co.kr/learn/courses/30/lessons/86971

n개의 송전탑이 전선을 통해 하나의 트리 형태로 연결되어 있습니다. 당신은 이 전선들 중 하나를 끊어서 현재의 전력망 네트워크를 2개로 분할하려고 합니다. 이때, 두 전력망이 갖게 되는 송전탑의 개수를 최대한 비슷하게 맞추고자 합니다.

송전탑의 개수 n, 그리고 전선 정보 wires가 매개변수로 주어집니다. 전선들 중 하나를 끊어서 송전탑 개수가 가능한 비슷하도록 두 전력망으로 나누었을 때, 두 전력망이 가지고 있는 송전탑 개수의 차이(절대값)를 return 하도록 solution 함수를 완성해주세요.

2. 코드

#include <string>
#include <vector>

using namespace std;

//dfs, visited 방법

int graph[101][101];
int visited[101];

int dfs(int cur, int n)
{
    if(visited[cur]) return 0;      //한번 방문한 곳은 재방문 X
    int child=1;      //하위 노드의 갯수
    visited[cur]=true;
    for(int i=1;i<=n;i++)
    {
        if(graph[cur][i])       //연결, 간적 없는 곳만
        {
            child+=dfs(i,n);
        }
    }
    return child;
}

void setGraph(int x,int y,int value)
{
    graph[x][y]=value;
    graph[y][x]=value;
}

int solution(int n, vector<vector<int>> wires) {
    int answer = 101;
    
    //연결되어 있는 모든 송전탑 1로 초기화
    for(int i=0;i<wires.size();i++){
        setGraph(wires[i][0],wires[i][1],1);
    }
    
    for(int i=0;i<wires.size();i++){
        //방문 배열 초기화
        fill_n(visited,101,false);
        
        //끊을 전선 0으로 만들어주기 -> 전선 끊기
        setGraph(wires[i][0],wires[i][1],0);

        vector<int> diff;
        for(int i=1;i<=n;i++)
        {
            int tmp=dfs(i,n);       //깊이 탐색
            if(!tmp)continue;       //방문한 경우 생략
            diff.push_back(tmp);
        }
        answer = min(answer, abs(diff[0]-diff[1]));
        if(answer==0)break;
        //원상태로 돌려놓기
        setGraph(wires[i][0],wires[i][1],1);
    }
    
    return answer;
}

3. 해설

//dfs, visited 방법

int solution(int n, vector<vector<int>> wires) {
    int answer = 101;
    
    //연결되어 있는 모든 송전탑 1로 초기화
    for(int i=0;i<wires.size();i++){
        setGraph(wires[i][0],wires[i][1],1);
    }
    
    for(int i=0;i<wires.size();i++){
        //방문 배열 초기화
        fill_n(visited,101,false);
        
        //끊을 전선 0으로 만들어주기 -> 전선 끊기
        setGraph(wires[i][0],wires[i][1],0);

        vector<int> diff;
        for(int i=1;i<=n;i++)
        {
            int tmp=dfs(i,n);       //깊이 탐색
            if(!tmp)continue;       //방문한 경우 생략
            diff.push_back(tmp);
        }
        answer = min(answer, abs(diff[0]-diff[1]));
        if(answer==0)break;
        //원상태로 돌려놓기
        setGraph(wires[i][0],wires[i][1],1);
    }
    
    return answer;
}

dfs를 이용해서 풀어야하는 문제이다. 처음에 문제를 접근할 때 dp로 접근하여서 노드의 하위 갯수를 누적하였었는데 해당 경우는 노드가 정렬되어 있지 않을 때 적합하지 않기 때문에 사용할 수 없었다.

푸는 순서는 다음과 같습니다.

1. 먼저 연결되어 있는 모든 송전탑들을 2차원 배열에 1로 표시해줍니다.

    //연결되어 있는 모든 송전탑 1로 초기화
    for(int i=0;i<wires.size();i++){
        setGraph(wires[i][0],wires[i][1],1);
    }

2. 0~n번째 송전탑을 각각 끊는 for 문을 이용하여 n번 돌려줍니다.

    for(int i=0;i<wires.size();i++){

3. 방문 배열을 초기화 해주고, 2차원 배열에서 끊을 송전탑을 0으로 만들어줍니다.

        //방문 배열 초기화
        fill_n(visited,101,false);
        
        //끊을 전선 0으로 만들어주기 -> 전선 끊기
        setGraph(wires[i][0],wires[i][1],0);

4. dfs 탐색을 통해 방문하지 않고 연결이 끊어지지 않은 곳까지 탐색을 하여 하위 노드의 갯수를 반환하고 그 값들의 차이를 반환합니다.

        vector<int> diff;
        for(int i=1;i<=n;i++)
        {
            int tmp=dfs(i,n);       //깊이 탐색
            if(!tmp)continue;       //방문한 경우 생략
            diff.push_back(tmp);
        }
        answer = min(answer, abs(diff[0]-diff[1]));
        if(answer==0)break;
        //원상태로 돌려놓기
        setGraph(wires[i][0],wires[i][1],1);

1. 문제

출처 : https://school.programmers.co.kr/learn/courses/30/lessons/87946

유저의 현재 피로도 k와 각 던전별 "최소 필요 피로도", "소모 피로도"가 담긴 2차원 배열 dungeons 가 매개변수로 주어질 때, 유저가 탐험할수 있는 최대 던전 수를 return 하도록 solution 함수를 완성해주세요.

2. 코드

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

//수열 next_permutation을 활용하여서 풀이
//경우의 수를 다 계산한 다음 차례로 검증함
int solution(int k, vector<vector<int>> dungeons) {
    int answer = 0;
    
    vector<int> v;
    // 0부터 던전 사이즈까지 벡터에 저장
	for(int i=0; i<dungeons.size(); i++){
		v.push_back(i);
	}
    
    do{
        int pirodo=k;
        int count=0;
		for(int i=0; i<v.size(); i++){
            if(pirodo>=dungeons[v[i]][0]){
                //피로도 차감 및 던전 갯수 올리기
                count++;
                pirodo-=dungeons[v[i]][1];
            }
		}
        answer=max(answer,count);
	}while(next_permutation(v.begin(),v.end()));
    
    return answer;
}

3. 해설

//수열 next_permutation을 활용하여서 풀이
//경우의 수를 다 계산한 다음 차례로 검증함
int solution(int k, vector<vector<int>> dungeons) {
    int answer = 0;
    
    vector<int> v;
    // 0부터 던전 사이즈까지 벡터에 저장
	for(int i=0; i<dungeons.size(); i++){
		v.push_back(i);
	}

경우의 수가 많지 않기에 완전 탐색을 통해 풀수 있는 문제이다.

정해진 배열에서 순서를 바꾸는 경우의 수를 구할 때는 수열을 사용해서 만들어준다.

먼저 0~ 던전의 갯수 까지의 배열을 만들어준다.

만약 던전의 갯수가 3이라면 [0,1,2] 가 만들어진다.

  do{
	int pirodo=k;
	int count=0;
	for(int i=0; i<v.size(); i++){
        	if(pirodo>=dungeons[v[i]][0]){
                //피로도 차감 및 던전 갯수 올리기
                count++;
                pirodo-=dungeons[v[i]][1];
            }
	}
    	answer=max(answer,count);
}while(next_permutation(v.begin(),v.end()));

만들어진 배열을 가지고 next_permutation() 함수를 통해서 수열의 경우의 수를 출력한다.

do while문을 통해 수열의 경우의 수를 받아올 때 피로도와 던전이 필요한 최소 피로도를 넘긴다면 던전을 클리어하도록 설계한다.

만약 최소 피로도를 넘기지 못하면 계산하지 않고 넘어간다.

계산이 끝난 후 만약 Count가 기존의 answer보다 클 경우 answer에 count 값을 삽입한다.

1. 문제

원본 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/42842

Leo가 본 카펫에서 갈색 격자의 수 brown, 노란색 격자의 수 yellow가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.

갈색 격자의 수 brown은 8 이상 5,000 이하인 자연수입니다.
노란색 격자의 수 yellow는 1 이상 2,000,000 이하인 자연수입니다.
카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.

2. 코드

#include <string>
#include <vector>

using namespace std;

vector<int> solution(int brown, int yellow) {
    vector<int> answer;
    
    //완전 탐색
    int sum = brown+yellow;
    for(int i=2;i<sum;i++){
        if(sum%i!=0) continue;
        else
        {
            if((i-2)*(sum/i-2)==yellow)
            {
                answer.push_back(sum/i);
                answer.push_back(i);
                break;
            }
            else continue;
        }
    }
    
    return answer;
}

3. 해설

//완전 탐색
    int sum = brown+yellow;
    for(int i=2;i<sum;i++){
        if(sum%i!=0) continue;

먼저 brown+yellow를 더하면 모든 타일의 갯수를 구할 수 있습니다.

타일의 갯수는 가로x세로의 경우의 수를 구할 수 있기에 구해줍니다.

타일의 세로 길이는 1보다 커야하기에(0이나 1인 경우 노란색 구역이 생길 수 없음) i=2부터 for문을 돌려줍니다.

if(sum%i!=0) : 만약 나누어 질수 없는 경우라면 가로 세로를 구할수 없기 때문에 계산하지 않고 넘어갑니다.

        else
        {
            if((i-2)*(sum/i-2)==yellow)
            {
                answer.push_back(sum/i);
                answer.push_back(i);
                break;
            }
            else continue;
        }
    }

나누어지는 경우라면, 해당 가로 세로의 길이에서 2씩 빼서 yellow 영역의 갯수를 구합니다.

만약 yellow 갯수가 맞다면 해당 값들을 answer에 저장해줍니다.

1. 문제

한자리 숫자가 적힌 종이 조각이 흩어져있습니다.

흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.
각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

2. 코드

#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int solution(string numbers) {
    int answer=0;
    
    //next_permutation을 사용
    //순열 계산에서 1자리,2자리 ~ n자리만 사용하는 모든 경우의 수 구하기
    sort(numbers.begin(),numbers.end());
    vector<unsigned int> nums;
    string sub;
    do {
        for (int i = 1; i <=  numbers.size(); i++)
        {
            sub = numbers.substr(0, i);
            nums.push_back(stoi(sub));
        }
    } while (next_permutation(numbers.begin(), numbers.end()));
    
    //중복된 숫자 제거하기
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(),nums.end()), nums.end());
    
    //에라토스테네스체 구하기
    unsigned int nn=9999999;
    vector<bool> isPrimeNum(nn+1);
    isPrimeNum[1] = true; // 1은 소수가 아니므로 true
    for(unsigned int i = 2; i <= sqrt(nn); i++){
        if(isPrimeNum[i]) continue; // 이미 true면 계산 제외
        for(unsigned int j = i + i; j <= nn; j += i) // i를 제외한 i의 배수들은 소수가 아니다.
            isPrimeNum[j] = true;
    }

    for(int i=0;i<nums.size();i++){
	    if(!isPrimeNum[nums[i]]&nums[i]>0)      //0인 경우 제외
            answer++;
    }
    
    return answer;
}

3. 해설

    //next_permutation을 사용
    //순열 계산에서 1자리,2자리 ~ n자리만 사용하는 모든 경우의 수 구하기
    sort(numbers.begin(),numbers.end());
    vector<unsigned int> nums;
    string sub;
    do {
        for (int i = 1; i <=  numbers.size(); i++)
        {
            sub = numbers.substr(0, i);
            nums.push_back(stoi(sub));
        }
    } while (next_permutation(numbers.begin(), numbers.end()));

먼저 경우의 수를 구하기 위해서 string을 정렬해주고, next_permutation 함수를 통해 1~n자리의 모든 경우의 수를 구합니다.

    //중복된 숫자 제거하기
    sort(nums.begin(), nums.end());
    nums.erase(unique(nums.begin(),nums.end()), nums.end());

그 후, 중복 경우의 수가 있을 수 있으므로, 중복된 숫자를 제거해줍니다.

    //에라토스테네스체 구하기
    unsigned int nn=9999999;
    vector<bool> isPrimeNum(nn+1);
    isPrimeNum[1] = true; // 1은 소수가 아니므로 true
    for(unsigned int i = 2; i <= sqrt(nn); i++){
        if(isPrimeNum[i]) continue; // 이미 true면 계산 제외
        for(unsigned int j = i + i; j <= nn; j += i) // i를 제외한 i의 배수들은 소수가 아니다.
            isPrimeNum[j] = true;
    }

에라토스테네스체의 해 알고리즘을 이용하여 주어진 범위 내에서 소수가 아닌 값들을 true로 표시해줍니다.

    for(int i=0;i<nums.size();i++){
	    if(!isPrimeNum[nums[i]]&nums[i]>0)      //0인 경우 제외
            answer++;
    }

소수 판별 vector isPrimeNum을 가지고 경우의 수들의 리스트 nums의 값과 비교하여 만약 소수가 아닌 경우(false) answer을 한개 늘려줍니다.

경우의 수가 0인경우는 소수가 아니기 떄문에 제외합니다.

큐를 가장 쉽게 이해하는 방법은 줄을 서서 하는 싸인회를 생각하면 된다.
예를 들어서 유명 가수의 싸인회가 열린다고 가정해보자
나는 가수의 싸인회에 당첨이 되었고 현장에서 3번의 번호를 부여받았다.
다른 팬들은 1~20번의 번호를 부여받았다고 가정하였을 때, 진행자가 1번부터 싸인을 받으러 오라고 부를 것이다.
그리고 2~20번의 사람들에게 차례로 줄을 서라고 할 것이고 그 다음 차례는 2번부터 순서대로 싸인을 받으러 줄을 이탈할 것이다.
이게 바로 큐의 개념이다! FIFO(First In First Out) 선입선출 자료구조이다.
먼저 들어간 데이터는 먼저 빠져나온다. 즉 2번이 맨 앞에 있는데 3번이 먼저 빠져나갈 수 없다는 것이다.

큐가 쓰이는 구조는 어디에 있을 까? 미루어 짐작해보건데
명절날 내려가는 KTX 예매를 할 때, 내 앞의 대기자 00명이 있습니다. 라는 문구를 본 적 있는가?
아마도 그러한 곳에 쓰일 것 같다.
물론 이것 말고도 많은 곳에 쓰이겠지만 가장 가시적으로 볼 수 있는 느낌이 아닐까 싶다.

스택은 굉장히 많이 쓰이는 개념이다.
’가장 먼저 들어간 데이터가 가장 마지막에 나오는(FILO, First In Last Out) 구조‘ 이다.
배열과 링크드 리스트 둘다 구현 가능한데 이전 포스팅에서 언급했듯이
탐색은 빠른 배열, 용량의 제한이 자유로운 링크드 리스트 이기에 데이터의 종류에 따라 다르게 쓰일 듯하다.

스택은 말그대로 쌓다 인데, 가장 와닿는 것은 프링글스 통이 아닐까 싶다..!
물론 프링글스를 뒤집으면 우르르 쏟아져나온다만은.. 프링글스는 위에서부터 꺼내서 제일 밑에까지 먹을 수 있는 과자이다.
반대로 프링글스 통에 과자를 다시 넣는다면 맨 마지막에 넣은 과자부터 꺼낼 수 있을 것이다.

스택을 사용하여서 어떤 것을 만들면 유용할까 하고 생각하여보았는데
아무래도 Undo, Redo 아닐까 싶다.
한글(.hwp)에서도 잘 볼 수 있는데, 단축키 Ctrl+Z 를 통해 이전의 작업으로 돌아가는 기능 말이다.
이전의 작업들을 한개한개씩 쌓아놓고, 만약 되돌아가기를 실행한다면 한큐에 작업했던 것들을 제거하면 이전의 작업으로 돌아갈 수 있을 것이다.

프로그램을 짜다보면 배열을 사용할 때가 많아진다.

배열은 크기가 한정되어 있기 때문에 공간이 모자라는 경우가 종종 생길 수 있는데, C++을 사용하는 사람들은 STL의 vector를 보통 떠올린다. 나의 경우도 그랬고

하지만 STL의 vector 경우 크기에 상관없이 자유자재로 늘어나는 것처럼 보이지만 배열 형태에서 배열이 가득 찰 때마다 크기를 1.5배 ~ 2배 (컴파일러에 따라 다름) 늘린 후 다시 옮겨담는 형식이라고 한다.

따라서 링크드 리스트랑은 다른 개념이다.

링크드 리스트는 C에서 배열의 크기가 한정되어 있는 한계를 극복하고자 만든 개념이다.

하지만 여러가지 장단점이 있기에 소개하려고 한다.

🔹01. 링크드 리스트

유연하게 크기를 바꿀 수 있는 구조를 보고 '리스트(list)'라고 하는데, 링크드 리스트는 이 중에서 가장 간단히 구현하는 방법이다.

'리스트' 내의 각 요소는 '노드(Node)' 라고 부른다.

'링크드'는 '연결된' 이라는 뜻이다. 즉 링크드 리스트는 연결된 리스트이다.

구조

노드는 데이터와 포인터를 가진 구조입니다.

포인터는 뒤에올 노드를 가르킴으로써 해당 포인터를 이용해 다음 노드를 탐색할 수 있다.

첫 번째 노드를 헤드, 마지막 노드를 테일이라고 부른다.

마치 KTX 기차를 이어붙이는 것 처럼 뒤를 이어서 붙인다.

기차 사이의 이음새 역활을 하는 고리가 노드의 포인터가 하는 역할이다.

struct Node
{
    Data data;		//데이터
    struct Node* NextNode;	//다음 노드를 가리키는 포인터
}

링크드 리스트를 설정하기 위해서는 코드블록이 종료됨에 따라 사라지지 않도록 malloc() 함수를 통해 할당을 해준다.

이러한 링크드 리스트는 탐색 연산에서 약점을 가지고 있다.

앞에서부터 쭈욱 연결된 구조이다 보니 HEAD부터 탐색을 시작해서 만약 10개의 노드 중 10번째 노드를 찾으려고 한다면 1번부터 탐색해서 10번까지 다달아야한다.

따라서 n개의 노드 중 n번째 노드를 찾으려고 한다면 n번 탐색을 진행해야하기에 비용이 크고 속도가 느리다.

❗배열에 비해 링크드 리스트의 장단점 정리❗

🔸단점🔸

  1. 포인터 때문에 각 노드마다 4 byte의 메모리가 추가로 필요함

  2. 최약의 경우 n회의 노드 탐색 루프 -> 비용이 크고 속도가 느림

🔸장점🔸

  1. 새로운 노드의 추가,삽입,삭제가 쉽고 빠름

따라서, 링크드 리스트는 추가,삽입,삭제가 잦고 조회는 드문 곳에 유용하다.

🔹02. 더블 링크드 리스트

더블 링크드 리스트는 링크드 리스트의 탐색 기능을 개선한 자료구조이다.

이전 노드를 참조하는 포인터를 하나 더 Node 안에 만들어서 양방향 탐색이 가능하도록 만들었다.

🔹03. 환형 링크드 리스트

환형 링크드 리스트는 헤드와 테일을 연결한 링크드 리스트이다.

이러한 방법을 사용하면 테일에 접근하는 비용이 작아져서, 뒤에서부터 노드를 찾아 나가는 탐색을 구현할 수 있다.

예를들어 10개의 노드 중 8번째를 찾고 싶다면 HEAD에서 TAIL로 2번 탐색하면 더 빠르게 찾을 수 있다.

🔅알아두면 좋은 TIP🔅

유연하게 크기를 바꿀 수 있는 구조를 보고 '리스트(list)'라고 하는데,

C++ STL vector도 리스트의 일종이라고 볼 수 있겠다.

여기서 C++ STL vector 는 동적 배열의 형태이고,

C++ STL list는 더블 링크드 리스트로 구성되어있다고 한다.

NavMeshAgent Documentation 원글 : https://docs.unity3d.com/ScriptReference/AI.NavMeshAgent.html

영어 그대로 직독직해하면 좋겠지만.. 익숙해지기 전에는 옮겨담으면서 파악하려고 한다..

Properties

Public Methods

Inherited Members(상속 멤버)

Properties

Public Methods

Static Methods

Operators

Unity에서 새롭게 적용된 TextMeshPro를 이용하여 쿨타임을 표시해주고 있었는데 도중에 사라지는 문제점을 발견하였다.

문제점은 같은 Material을 사용하고 있는 TextMeshPro 가 발동될 때 대부분 사라지는 현상을 발견하였다.(일부는 시작하자마자 존재)

레이어 문제인가 싶어서 Layout order관련 코드들을 삽입해보기도 했는데 문제는 나아지지 않았다.

나의 경우 Canvas 위에서 사용하는 TextMeshPro UGUI(TextMeshPro - Text(UI))에서의 문제점이였다.

타격시 몬스터의 데미지 표시용으로 사용되는 TextMeshPro가 사용되면 생기는 문제였다.

머테리얼의 문제라 보고 사용하고 있는 TMP_Font Asset에 새로운 머테리얼을 추가하여 서로 다른 머테리얼로 적용하였더니 문제점이 사라졌다.

기존에 사용하고 있던 LiberationSans와 같은 Shader를 이용하는 Material을 추가로 만들어준다.

하지만 그렇게 제작한 것이 Material Preset에는 보이지 않는데.. 그 이유는 이름때문이다.

이름의 앞을 똑같이 LiberationSans SDF 로 바꿔주면 Material에서 보인다.

타격시 발생하는 TextMeshPro와 CoolTime에서의 TextMeshPro를 다른 Material로 변경하니까 해결되었다.

Unity에서 LoadScene 함수를 이용하여 Scene간의 전환을 하고 있었는데 예전 버전에서는 발견하지 못한 다크닝 현상을 발견하였다.

Window -> Rendering -> Lighting 을 누르면 아래 그림과 같은 창이 나타난다

Generate Lighting 을 누르면 알아서 조명 관련 필요한 것들을 만들어준다

별도로 어디에 넣어주거나 할 필요없이 잘 작동된다.

원본 : https://ogldev.org/www/tutorial38/tutorial38.html

배경

마침내 수백만명의 독자들이 요구해온 튜토리얼. 스키닝으로도 알려진 골격 애니메이션으로, Assimp 라이브러리를 사용합니다.

골격 애니메이션은 사실 두 부분으로 이루어진 과정입니다.

첫 번째는 아티스트가 실행하고 두 번째는 프로그래머인 사용자(또는 작성한 엔진)가 실행합니다.

첫 번째 부분은 모델링 소프트웨어 내부에서 발생하며 리깅이라고 합니다.

여기서 일어나는 일은 아티스트가 mesh 아래 뼈(skeleton)의 골격(bones)을 정의하는 것입니다.

mesh는 물체의 피부(인간이든 괴물이든 무엇이든)를 나타내며 skeleton은 실제 세계에서 실제 움직임을 모방하는 방식으로 mesh를 움직이는데 사용됩니다.

이 작업은 각 정점을 하나 이상의 뼈에 할당하여 수행됩니다.

정점이 뼈에 할당되면 뼈가 이동할 때 정점에 미치는 영향의 양을 결정하는 가중치가 정의됩니다.

일반적인 방법은 모든 가중치의 합을 (정점당) 1로 만드는 것입니다.

예를 들어, 꼭짓점이 두 뼈 사이에 정확히 위치한다면 우리는 뼈가 꼭짓점에 미치는 영향이 같을 것으로 예상하기 때문에 각 뼈에 0.5의 가중치를 할당하고 싶을 것입니다. 그러나 꼭짓점이 완전히 단일 뼈의 영향 범위 내에 있는 경우 가중치는 1이 됩니다(뼈가 정점의 움직임을 자율적으로 제어함).

블렌더에서 생성된 골격 구조의 예는 다음과 같습니다:

우리가 위에서 본 것은 사실 애니메이션의 중요한 부분입니다. 아티스트는 골격 구조를 연결하고 각 애니메이션 유형("walk","run","die" 등)에 대한 키 프레임 세트를 정의합니다.

키 프레임에는 애니메이션 경로를 따라 임계점에 있는 모든 뼈의 변환이 포함되어 있습니다.

그래픽 엔진은 키 프레임의 변환 사이를 보간하여 키 프레임 간의 부드러운 움직임을 만듭니다.

골격 애니메이션에 사용되는 골격 구조는 종종 계층 구조입니다.

이것은 skeleton이 자식/부모 관계를 가지고 있으므로 skeleton tree가 생성된다는 것을 의미합니다.

root bone을 제외한 모든 뼈에는 부모가 하나씩 있습니다.

예를 들어, 인체의 경우 팔, 다리, 손가락 뼈와 같은 자식 뼈를 다음 단계로 하여 등뼈를 root로 지정할 수 있습니다.

부모의 뼈가 움직이면 모든 자식 뼈들도 움직이지만, 자식의 뼈가 움직이면 부모는 움직이지 않습니다(우리의 손가락은 손을 움직이지 않고도 움직일 수 있지만, 손이 움직이면 모든 손가락이 움직입니다). 실질적인 관점에서 이것은 우리가 뼈의 변형을 처리할 때 그것을 그것으로부터 root로 이끄는 모든 부모 뼈의 변형과 결합할 필요가 있다는 것을 의미합니다.

더 이상 조작에 대해 논의하지 않을 것입니다. 그것은 그래픽 프로그래머의 영역 밖에 있는 복잡한 주제입니다. 모델링 소프트웨어는 예술가가 이 일을 할 수 있도록 도와주는 고급 도구를 가지고 있으며 당신은 멋집 mesh와 skeleton을 만들기 위해 훌륭한 예술가가 되어야 합니다. skeletal 애니메이션을 만들기 위해 그래픽 엔진이 무엇을 해야 하는지 알아보겠습니다.

첫 번재 단계는 정점 버퍼를 정점별 골격 정보로 보강하는 것입니다.

몇 가지 옵션을 사용할 수 있지만 우리가 하려는 것은 매우 간단합니다.

각 꼭짓점에 대해 각 슬롯에 골격 ID와 가중치가 포함된 슬롯 배열을 추가합니다.

우리의 삶을 더 단순하게 만들기 위해 우리는 4개의 슬롯이 있는 배열을 사용할 것입니다.

이것은 4개 이상의 뼈에 의해 영향을 받을 수 있는 정점이 없다는 것을 의미합니다.

골격이 더 많은 모델을 로드하려면 배열 크기를 조정해야 하지만 이 튜토리얼 데모에 포함된 Doom 3 모델의 경우 골격 4개로 충분합니다. 그래서 우리의 새로운 꼭짓점 구조는 다음과 같이 보일 것입니다.

bone ID는 bone 변환 배열의 인덱스입니다.

이러한 변환은 WVP 행렬 앞의 위치와 정규에 적용됩니다(즉, 정점을 "bone space"에서 로컬 공간으로 변환).

가중치는 여러 뼈의 변환을 하나의 변환으로 결합하는 데 사용되며, 어떤 경우에도 총 가중치는 정확히 1(모델링 소프트웨어의 책임)이어야 합니다. 일반적으로 애니메이션 키 프레임 사이를 보간하고 모든 프레임의 골격 변환 배열을 업데이트합니다.

뼈 변형의 배열이 만들어지는 방법은 대개 까다로운 부분입니다.

변환은 계층 구조(즉, 트리)로 설정되며 일반적인 방법은 트리의 모든 노트에 스케일링 벡터, 회전 쿼터 및 변환 벡터를 갖는 것입니다.

실제로 각 노드에는 이러한 항목의 배열이 포함되어 있습니다. 배열의 모든 항목에는 타임스탬프가 있어야합니다. 응용 프로그램 시간이 타임스탬프 중 하나와 정확히 일치하는 경우는 드물기 때문에 응용 프로그램의 시점에 대한 정확한 변환을 얻으려면 코드가 스케일링/회전/번역을 보간할 수 있어야 합니다.

우리는 현재의 뼈에서 root까지 각 노드에 대해 동일한 프로세스를 수행하고 이 변환 체인을 함께 곱하여 최종 결과를 얻습니다. 각 골격에 대해 이 작업을 수행한 다음 쉐이더를 업데이트합니다.

지금까지 우리가 이야기한 모든 것은 꽤 일반적이었습니다.

하지만 이것은 Assimp의 골격 애니메이션에 대한 튜토리얼 입니다.

그래서 우리는 그 라이브러리에 다시 들어가서 어떻게 스키닝을 할 수 있는지 볼 필요가 있습니다.

Assimip의 좋은 점은 여러 형식의 골격 정보 로드를 지원한다는 것입니다.

나쁜점은 쉐이더에 필요한 골격 변환을 생성하기 위해 생성되는 데이터 구조에 대해 여전히 상당한 작업이 필요하다는 것입니다.

정점 수준의 뼈 정보부터 시작해보겠습니다. 다음은 Assimp 데이터 구조의 관련 부분입니다:

아마 Assimp에 대한 튜토리얼에서 기억하시겠지만, 모든 것이 aiScene 클래스(매쉬 파일을 가져올 때 받는 개체)에 포함되어 있습니다. aiScene에는 aiMesh 개체의 배열이 포함되어 있습니다. aiMesh는 모델의 일부이며 위치, 정규 텍스처 좌표 등과 같은 정점 수준의 항목을 포함합니다. 이제 aiMesh에는 aiBone 객체의 배열도 포함되어 있습니다.

놀랄 것도 없이, aiBone은 mesh의 골격에 있는 하나의 뼈를 나타냅니다. 각 골격에는 골격 계층 구조(아래 참조), 정점 가중치 배열 및 4x4 오프셋 행렬에서 찾을 수 있는 이름이 있습니다. 이 행렬이 필요한 이유는 정점이 일반적인 로컬 공간에 저장되기 때문입니다. 이는 골격 애니메이션이 지원되지 않더라도 기존 코드 기반이 모델을 로드하고 올바르게 렌더링할 수 있음을 의미합니다. 그러나 계층 구조의 뼈 변환은 뼈 공간에서 작동합니다.(그리고 모든 뼈는 고유한 공간을 가지고 있습니다. 이것이 우리가 함께 변환을 곱해야 하는 이유입니다). 오프셋 매트릭스의 작업은 매쉬의 국소 공간에서 정점 위치를 특정 뼈의 공간으로 이동시키는 것입니다.

정점 가중치 배열은 사물들이 흥미로워지기 시작하는 곳입니다.

이 배열의 각 항목에는 aiMesh의 정점 배열에 대한 인덱스(꼭짓점이 동일한 길이를 가진 여러 배열에 걸쳐 분산됨)와 가중치가 포함됩니다. 모든 꼭짓점 가중치의 합은 1이어야 하지만 이를 찾으려면 모든 뼈를 통과하고 각 특정 꼭짓점에 대한 일종의 목록으로 가중치를 누적해야 합니다.

정점 수준에서 골격 정보를 구축한 후 골격 변환 계층 구조를 처리하고 쉐이더에 로드할 최종 변환을 생성해야 합니다. 다음 그림에는 관련 데이터 구조가 표시되어 있습니다:

다시, 우리는 aiScene에서 시작합니다. aiScene 개체에는 노드 계층 구조(즉, 트리)의 루트인 aiNode 클래스의 개체에 대한 포인터가 포함되어 있습니다. 트리의 각 노드에는 부모에 대한 포인터와 자식에 대한 포인터 배열이 있습니다. 이것은 우리가 tree를 편리하게 왔다갔다 할 수 있게 해줍니다.

또한 노드는 노드 공간에서 부모 공간으로 변환하는 변환 행렬을 전달합니다. 마지막으로 노드에 이름이 있을 수도 있고 없을 수도 있습니다. 노드가 계층에서 골격을 나타내는 경우 노드 이름이 골격 이름과 일치해야 합니다. 그러나 노드에 이름이 없는 경우(즉, 대응하는 골격이 없음) 노드의 역할은 단순히 모델을 분해하고 중간 변환을 배치하는 것을 돕는 것입니다.

퍼즐의 마지막 조각은 aiScene 객체에도 저장된 aiAnimation 배열입니다. 단일 aiAnimation 객체는 "walk", "run", "shoot" 등과 같은 일련의 애니메이션 프레임을 나타냅니다. 프레임 사이를 보간함으로써 애니메이션 이름과 일치하는 원하는 시각적 효과를 얻을 수 있습니다. 애니메이션에는 눈금의 지속 시간과 초당 눈금 수(예: 100개의 눈금과 25개의 눈금은 4초의 애니메이션을 나타냄)가 있어 애니메이션이 모든 하드웨어에서 동일하게 보이도록 진행 시간을 조정할 수 있습니다. 또한 이 애니메이션에는 채널이라고 하는 aiNodeAnim 객체의 배열이 있습니다. 각각의 채널은 사실 모든 변형이 있는 뼈입니다. 채널에는 계층 구조의 노드 중 하나와 세 개의 변환 배열과 일치해야 하는 이름이 포함되어 있습니다.

특정 시점의 최종 뼈 변환을 계산하기 위해서는 이 세 배열에서 각각 시간과 일치하는 두 개의 항목을 찾고 그 사이를 보간해야 합니다. 그런 다음 변환을 하나의 행렬로 결합해야 합니다. 이 작업을 수행한 후에는 계층 구조에서 해당 노드를 찾아 상위 노드로 이동해야 합니다. 그러면 부모에 해당하는 채널이 필요하고 동일한 보간 과정을 수행해야 합니다. 우리는 두 변환을 함께 곱하고 계층의 root에 도달할 때까지 계속합니다.

Source Walthru

(mesh.cpp:75)

bool Mesh::LoadMesh(const string& Filename)
{
    // Release the previously loaded mesh (if it exists)
    Clear();

    // Create the VAO
    glGenVertexArrays(1, &m_VAO);
    glBindVertexArray(m_VAO);

    // Create the buffers for the vertices attributes
    glGenBuffers(ARRAY_SIZE_IN_ELEMENTS(m_Buffers), m_Buffers);

    bool Ret = false;

    m_pScene = m_Importer.ReadFile(Filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals |
                                    aiProcess_FlipUVs);

    if (m_pScene) {
       m_GlobalInverseTransform = m_pScene->mRootNode->mTransformation;
       m_GlobalInverseTransform = m_GlobalInverseTransform.Inverse();
       Ret = InitFromScene(m_pScene, Filename);
    }
    else {
       printf("Error parsing '%s': '%s'\n", Filename.c_str(), m_Importer.GetErrorString());
    }

    // Make sure the VAO is not changed from the outside
    glBindVertexArray(0);

    return Ret;
}

다음은 매쉬 클래스의 업데이트된 진입점으로, 변경 사항은 굵은 글씨로 표시됩니다. 우리가 주목해야 할 몇 가지 변화가 있습니다. 하나는 임포터와 aiScene 개체가 이제 변수를 쌓지 않고 클래스 멤버가 된다는 것입니다. 그 이유는 런타임 중에 우리는 aiScene 객체로 다시 돌아갈 것이기 때문에 수입자와 장면의 범위를 모두 확장해야 합니다. 실제 게임에서는 필요한 것을 복사하여 최적화된 형식으로 저장하고 싶을 수 있지만 교육적인 목적을 위해서는 이것으로 충분합니다.

두 번째 변경 사항은 계층 구조의 루트에 대한 변환 행렬이 추출되고 역방향으로 저장된다는 것입니다. 우리는 앞으로 더 멀리서 그것을 사용할 것입니다. 행렬 역코드가 Assimp 라이브러리에서 Matrix4f 클래스로 복사되었습니다.

(mesh.h:69)

struct VertexBoneData
{
    uint IDs[NUM_BONES_PER_VERTEX];
    float Weights[NUM_BONES_PER_VERTEX];
}

(mesh.cpp:107)

bool Mesh::InitFromScene(const aiScene* pScene, const string& Filename)
{
    ...
    vector<VertexBoneData> Bones;
    ...
    Bones.resize(NumVertices);
    ...
    glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[BONE_VB]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Bones[0]) * Bones.size(), &Bones[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(BONE_ID_LOCATION);
    glVertexAttribIPointer(BONE_ID_LOCATION, 4, GL_INT, sizeof(VertexBoneData), (const GLvoid*)0);
    glEnableVertexAttribArray(BONE_WEIGHT_LOCATION);
    glVertexAttribPointer(BONE_WEIGHT_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(VertexBoneData), (const GLvoid*)16);
    ...
}

위의 구조는 꼭짓점 수준에서 우리가 필요로 하는 모든 것을 포함하고 있습니다. 기본적으로 4개의 뼈(뼈당 ID 및 무게)를 저장할 수 있는 충분한 저장 공간이 있습니다.

VertexBoneData는 쉐이더에 쉽게 전달할 수 있도록 그렇게 구성되었습니다. 우리는 이미 위치 0, 1, 2에 각각 위치, 텍스처 좌표 및 일반 경계를 확보했습니다. 따라서 위치 3에서 골격 ID를 바인딩하고 위치 4에서 가중치를 바인딩하도록 VAO를 구성합니다. 우리가 glVertexAttribute를 사용한다는 것을 주목하는 것도 매우 중요합니다. ID를 바인딩할 glVertexAttributePointer가 아닌 IPointer입니다. 이 점에 주의하십시오. 그렇지 않으면 쉐이더에 손상된 데이터가 표시됩니다.

(mesh.cpp:213)

void Mesh::LoadBones(uint MeshIndex, const aiMesh* pMesh, vector& Bones)
{
    for (uint i = 0 ; i < pMesh->mNumBones ; i++) {
        uint BoneIndex = 0;
        string BoneName(pMesh->mBones[i]->mName.data);

        if (m_BoneMapping.find(BoneName) == m_BoneMapping.end()) {
            BoneIndex = m_NumBones;
            m_NumBones++;
            BoneInfo bi;
            m_BoneInfo.push_back(bi);
        }
        else {
            BoneIndex = m_BoneMapping[BoneName];
        }

        m_BoneMapping[BoneName] = BoneIndex;
        m_BoneInfo[BoneIndex].BoneOffset = pMesh->mBones[i]->mOffsetMatrix;

        for (uint j = 0 ; j < pMesh->mBones[i]->mNumWeights ; j++) {
            uint VertexID = m_Entries[MeshIndex].BaseVertex + pMesh->mBones[i]->mWeights[j].mVertexId;
            float Weight = pMesh->mBones[i]->mWeights[j].mWeight;
            Bones[VertexID].AddBoneData(BoneIndex, Weight);
        }
    }
}

위의 함수는 단일 aiMesh 개체에 대한 정점 골격 정보를 로드합니다. Mesh::InitMesh()에서 호출됩니다. 이 함수는 VertexBoneData 구조를 채우는 것 외에도 골격 이름과 골격 ID(이 함수에 의해 관리되는 실행중인 인덱스) 사이의 맵을 업데이트하고 골격 ID를 기반으로 벡터에 오프셋 행렬을 저장합니다. 정점 ID가 계산되는 방법을 기록합니다. 정점 ID는 단일 매쉬와 관련이 있고 모든 매쉬를 단일 벡터에 저장하기 때문에 현재 aiMesh의 기본 정점 ID를 mWeights 배열의 정점 ID에 추가하여 절대 정점 ID를 얻습니다.

(mesh.cpp:29)

void Mesh::VertexBoneData::AddBoneData(uint BoneID, float Weight)
{
    for (uint i = 0 ; i < ARRAY_SIZE_IN_ELEMENTS(IDs) ; i++) {
        if (Weights[i] == 0.0) {
            IDs[i] = BoneID;
            Weights[i] = Weight;
            return;
        }
    }

    // should never get here - more bones than we have space for
    assert(0);
}

이 유틸리티 함수는 VertexBoneData 구조에서 빈 슬롯을 찾아 골격 ID와 가중치를 배치합니다. 일부 정점은 4개 미만의 뼈에 의해 영향을 받지만 존재하지 않는 뼈의 무게가 0으로 유지되기 때문에(VertexBoneData 생성자 참조), 이는 모든 뼈 수에 대해 동일한 가중치 계산을 사용할 수 있습니다.

 (mesh.cpp:473)

Matrix4f Mesh::BoneTransform(float TimeInSeconds, vector<Matrix4f>& Transforms)
{
    Matrix4f Identity;
    Identity.InitIdentity();

    float TicksPerSecond = m_pScene->mAnimations[0]->mTicksPerSecond != 0 ?
                            m_pScene->mAnimations[0]->mTicksPerSecond : 25.0f;
    float TimeInTicks = TimeInSeconds * TicksPerSecond;
    float AnimationTime = fmod(TimeInTicks, m_pScene->mAnimations[0]->mDuration);

    ReadNodeHierarchy(AnimationTime, m_pScene->mRootNode, Identity);

    Transforms.resize(m_NumBones);

    for (uint i = 0 ; i < m_NumBones ; i++) {
        Transforms[i] = m_BoneInfo[i].FinalTransformation;
    }
}

앞서 본 정점 수준의 골격 정보 로드는 매쉬가 시작 중에 로드될 때 한 번만 수행됩니다. 이제 우리는 매 프레임마다 쉐이더에 들어가는 뼈 변형을 계산하는 두 번재 부분으로 넘어갑니다. 위의 기능은 이 활동의 시작점입니다. 호출자는 현재 시간을 초 단위로 보고하고(분수일 수 있음), 업데이트해야하는 행렬의 벡터를 제공합니다. 우리는 애니메이션 주기 내에서 상대적인 시간을 찾고 노드 계층 구조를 처리합니다. 결과는 호출자에게 반환되는 일련의 변환입니다.

(mesh.cpp:428)

void Mesh::ReadNodeHierarchy(float AnimationTime, const aiNode* pNode, const Matrix4f& ParentTransform)
{
    string NodeName(pNode->mName.data);

    const aiAnimation* pAnimation = m_pScene->mAnimations[0];

    Matrix4f NodeTransformation(pNode->mTransformation);

    const aiNodeAnim* pNodeAnim = FindNodeAnim(pAnimation, NodeName);

    if (pNodeAnim) {
        // Interpolate scaling and generate scaling transformation matrix
        aiVector3D Scaling;
        CalcInterpolatedScaling(Scaling, AnimationTime, pNodeAnim);
        Matrix4f ScalingM;
        ScalingM.InitScaleTransform(Scaling.x, Scaling.y, Scaling.z);

        // Interpolate rotation and generate rotation transformation matrix
        aiQuaternion RotationQ;
        CalcInterpolatedRotation(RotationQ, AnimationTime, pNodeAnim);
        Matrix4f RotationM = Matrix4f(RotationQ.GetMatrix());

        // Interpolate translation and generate translation transformation matrix
        aiVector3D Translation;
        CalcInterpolatedPosition(Translation, AnimationTime, pNodeAnim);
        Matrix4f TranslationM;
        TranslationM.InitTranslationTransform(Translation.x, Translation.y, Translation.z);

        // Combine the above transformations
        NodeTransformation = TranslationM * RotationM * ScalingM;
    }

    Matrix4f GlobalTransformation = ParentTransform * NodeTransformation;

    if (m_BoneMapping.find(NodeName) != m_BoneMapping.end()) {
        uint BoneIndex = m_BoneMapping[NodeName];
        m_BoneInfo[BoneIndex].FinalTransformation = m_GlobalInverseTransform * GlobalTransformation *
                                                    m_BoneInfo[BoneIndex].BoneOffset;
    }

    for (uint i = 0 ; i < pNode->mNumChildren ; i++) {
        ReadNodeHierarchy(AnimationTime, pNode->mChildren[i], GlobalTransformation);
    }
}

이 함수는 노드 트리를 통과하고 지정된 애니메이션 시간에 따라 각 노드/본에 대한 최종 변환을 생성합니다. 매쉬가 하나의 애니메이션 시퀀스만 가지고 있다고 가정한다는 점에서 제한적입니다.

여러 애니메이션을 지원하려면 애니메이션 이름을 말하고 m_pScene->mAnimations[] 배열에서 검색해야 합니다. 위의 코드는 우리가 사용하는 데모 매쉬에 충분합니다.

노드 변환은 노드의 mTransformation 멤버에서 초기화됩니다. 만약 노드가 뼈와 일치하지 않는다면 그것이 뼈의 최종변환입니다. 그렇게 되면 생성한 행렬로 덮어씁니다. 이 작업은 다음과 같이 수행됩니다. 먼저 애니메이션의 채널 배열에서 노드 이름을 검색합니다. 그런 다음 애니메이션 시간을 기반으로 스케일링 벡터, 회전 쿼터 및 변환 벡터를 보간합니다. 우리는 그것들을 하나의 행렬로 결합하고 매개 변수로 얻은 행렬(GlobablTransformation)로 곱합니다.

이 함수는 재귀적이며 글로벌 변환 매개 변수가 ID 매트릭스인 root 노드에 대해 호출됩니다. 각 노드는 모든 자식에 대해 이 함수를 재귀적으로 호출하고 자체 변환을 전역 변환으로 전달합니다. 처음부터 끝까지 모든 노드에서 통합된 변환 체임을 얻을 수 있습니다.

m_BoneMapping 배열은 노드 이름을 생성하는 인덱스에 매핑하고 이 인덱스를 최종 변환이 저장되는 m_BoneInfo 배열의 항목으로 사용합니다. 최종 변환은 다음과 같이 계산됩니다. 우리는 로컬 공간 위치에서 정점을 노드 공간으로 가져오는 노드 오프셋 행렬로 시작합니다. 그런 다음 모든 노드 부모의 결합된 변환과 애니메이션 시간에 따라 노드에 대해 계산한 특정 변환을 곱합니다.

여기서는 Assimp 코드를 사용하여 수학 문제를 처리합니다. 나는 그것을 우리만의 코드 베이스로 복제하는 것이 의미가 없다고 생각해서 그냥 Assimp를 사용했습니다.

(mesh.cpp:387)

void Mesh::CalcInterpolatedRotation(aiQuaternion& Out, float AnimationTime, const aiNodeAnim* pNodeAnim)
{
    // we need at least two values to interpolate...
    if (pNodeAnim->mNumRotationKeys == 1) {
        Out = pNodeAnim->mRotationKeys[0].mValue;
        return;
    }

    uint RotationIndex = FindRotation(AnimationTime, pNodeAnim);
    uint NextRotationIndex = (RotationIndex + 1);
    assert(NextRotationIndex < pNodeAnim->mNumRotationKeys);
    float DeltaTime = pNodeAnim->mRotationKeys[NextRotationIndex].mTime - pNodeAnim->mRotationKeys[RotationIndex].mTime;
    float Factor = (AnimationTime - (float)pNodeAnim->mRotationKeys[RotationIndex].mTime) / DeltaTime;
    assert(Factor >= 0.0f && Factor <= 1.0f);
    const aiQuaternion& StartRotationQ = pNodeAnim->mRotationKeys[RotationIndex].mValue;
    const aiQuaternion& EndRotationQ = pNodeAnim->mRotationKeys[NextRotationIndex].mValue;
    aiQuaternion::Interpolate(Out, StartRotationQ, EndRotationQ, Factor);
    Out = Out.Normalize();
}

이 방법은 애니메이션 시간을 기준으로 지정된 채널의 회전쿼터를 보간합니다(채널에 키 쿼터 배열이 포함되어 있음). 먼저 필요한 애니메이션 시간 직전의 핵심 쿼터의 인덱스를 찾습니다. 애니메이션 시간에서 이전 키까지의 거리와 해당 키와 다음 키 사이의 거리 사이의 비율을 계산합니다. 우리는 그 요소를 사용하여 이 두 키 사이를 보간해야 합니다. 우리는 Assimp 코드를 사용하여 보간을 수행하고 결과를 정규화합니다. 위치 및 스케일링에 대한 해당 방법은 매우 유사하므로 여기서는 인용하지 않습니다.

(mesh.cpp:335)

uint Mesh::FindRotation(float AnimationTime, const aiNodeAnim* pNodeAnim)
{
    assert(pNodeAnim->mNumRotationKeys > 0);

    for (uint i = 0 ; i < pNodeAnim->mNumRotationKeys - 1 ; i++) {
        if (AnimationTime < (float)pNodeAnim->mRotationKeys[i + 1].mTime) {
            return i;
        }
    }

    assert(0);
}

이 유틸리티 방법은 애니메이션 시간 직전의 키 회전을 찾습니다. N 키 회전이 있으면 결과는 0에서 N-2가 될 수 있습니다. 애니메이션 시간은 항상 채널의 지속 시간 내에 포함되므로 마지막 키(N-1)는 유효한 결과가 될 수 없습니다.

(skihnning.vs)

#version 330

layout (location = 0) in vec3 Position;
layout (location = 1) in vec2 TexCoord;
layout (location = 2) in vec3 Normal;
layout (location = 3) in ivec4 BoneIDs;
layout (location = 4) in vec4 Weights;

out vec2 TexCoord0;
out vec3 Normal0;
out vec3 WorldPos0;

const int MAX_BONES = 200;

uniform mat4 gWVP;
uniform mat4 gWorld;
uniform mat4 gBones[MAX_BONES];

void main()
{
    mat4 BoneTransform = gBones[BoneIDs[0]] * Weights[0];
    BoneTransform += gBones[BoneIDs[1]] * Weights[1];
    BoneTransform += gBones[BoneIDs[2]] * Weights[2];
    BoneTransform += gBones[BoneIDs[3]] * Weights[3];

    vec4 PosL = BoneTransform * vec4(Position, 1.0);
    gl_Position = gWVP * PosL;
    TexCoord0 = TexCoord;
    vec4 NormalL = BoneTransform * vec4(Normal, 0.0);
    Normal0 = (gWorld * NormalL).xyz;
    WorldPos0 = (gWorld * PosL).xyz;
}

이제 매쉬 클래스의 변경 작업을 마쳤으므로 쉐이더 수준에서 수행해야 할 작업을 살펴보겠습니다.

먼저 VSInput 구조에 골격 ID 및 가중치 배열을 추가했습니다.

다음으로, 골격 변환을 포함하는 새로운 균일 배열이 있습니다. 쉐이더 자체에서 우리는 정점의 뼈 변환 행렬과 가중치의 조합으로 최종 뼈 변환을 계산합니다. 이 최종 행렬은 위치와 노말을 골격 공간에서 로컬 공간으로 변환하는데 사용됩니다. 여기서 부터 모든 것이 동일합니다.

(tutorial38.cpp:140)

float RunningTime = (float)((double)GetCurrentTimeMillis() - (double)m_startTime) / 1000.0f;

m_mesh.BoneTransform(RunningTime, Transforms);

for (uint i = 0 ; i < Transforms.size() ; i++) {
    m_pEffect->SetBoneTransform(i, Transforms[i]);
}

우리가 마지막으로 해야 할 일은 이 모든 것들을 애플리케이션 코드에 통합하는 것입니다.

이 작업은 위의 간단한 코드로 수행됩니다. 이 작업은 위의 간단한 코드로 수행됩니다.

GetCurrentTimeMillis() 함수는 응용 프로그램 시작 이후의 시간을 밀리초 단위로 반환합니다(분수를 수용하려면 부동 소수점을 참고하십시오).

모든 작업을 올바르게 수행한 경우 최종 결과는 이것과 유사합니다.

소스 코드 주소 : https://github.com/emeiri/ogldev/tree/master/tutorial28_youtube

원본 : http://www.opengl-tutorial.org/kr/intermediate-tutorials/tutorial-16-shadow-mapping/

튜토리얼 15에서는 정적 조명을 포함하는 라이트 맵을 만드는 방법을 배웠습니다.

아주 멋진 그림자를 만들어내기는 하지만, 애니메이션 모델은 다루지 않습니다.

Shadow Map은 현재(2016년 기준) 동적 Shadow를 만드는 방법입니다. 이 방법의 좋은 점은 작업을 시작하기에 꽤 쉽다는 것입니다. 나쁜점은 제대로 작업 하기가 매우 어렵다는 것입니다.

이 튜토리얼에서는 먼저 기본 알고리즘을 소개하고 단점을 확인한 다음 몇 가지 기술을 구현하여 더 나은 결과를 얻을 것입니다. Shadow Map을 작성할 당시(2012년)에는 여전히 많은 연구가 진행 중인 주제이기 때문에 필요에 따라 자체 Shadow Map을 더욱 개선할 수 있는 몇 가지 방법을 알려드리겠습니다.

기본 Shadowmap

기본 Shadow Map 알고리즘은 두 개의 패스로 구성됩니다.

먼저, 장면은 빛의 관점에서 렌더링됩니다. 각 fragment의 깊이만 계산됩니다.

그런 다음 씬(scene)이 평소와 같이 렌더링되지만 추가 테스트를 통해 현재 조각이 그림자에 표시됩니다.

"그림자 속에 있는 물체" 테스트는 사실 매우 간단합니다.

현재 샘플이 동일한 점에서 그림자 맵보다 빛에서 멀리 떨어져 있으면 씬(scene)에 빛에 더 가까운 개체가 포함되어 있음을 의미합니다.

즉, 현재 fragment는 그림자에 있습니다.

다음 이미지는 원리를 이해하는 데 도움이 될 수 있습니다.

Shadowmap 렌더링하기

이 튜토리얼에서는 directional lights(모든 광선이 평행하다고 간주될 수 있을 정도로 멀리 떨어져 있는 조명)만 고려합니다. 따라서 Shadow Map 렌더링은 직교 투영 행렬을 사용하여 수행됩니다. 직교 행렬은 원근법이 고려되지 않는다는 점을 제외하고는 일반적인 원근법 투영 행렬과 같습니다. 물체는 카메라 가까이에 있는 멀리있든 동일하게 보입니다.

렌더 대상 및 MVP 매트릭스 설정

튜토리얼 14부터는 쉐이더에서 나중에 액세스하기 위해 장면을 텍스처로 렌더링하는 방법을 배웠습니다.

여기서는 Shadow Map을 포함하기 위해 1024x1024 16비트 depth 텍스처를 사용합니다.

Shadow Map에는 일반적으로 16비트로 충분합니다. 이 값들을 자유롭게 시험해보세요. 나중에 샘플링해야 하므로 depth 렌더 버퍼가 아닌 depth 텍스처를 사용합니다.

// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
 GLuint FramebufferName = 0;
 glGenFramebuffers(1, &FramebufferName);
 glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);

 // Depth texture. Slower than a depth buffer, but you can sample it later in your shader
 GLuint depthTexture;
 glGenTextures(1, &depthTexture);
 glBindTexture(GL_TEXTURE_2D, depthTexture);
 glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, 1024, 1024, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

 glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthTexture, 0);

 glDrawBuffer(GL_NONE); // No color buffer is drawn to.

 // Always check that our framebuffer is ok
 if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
 return false;

빛의 관점에서 장면을 렌더링하는 데 사용되는 MVP 매트릭스는 다음과 같이 계산됩니다:

• Projection 행렬은 X,Y 및 Z 축에서 각각 축 정렬 상자(-10, 10), (-10,10), (-10, 20)의 모든 것을 포함하는 직교 행렬입니다. 이러한 값은 전체 *가시적인* 장면을 항상 볼 수 있도록 만들어졌으며, 이에 대한 자세한 내용은 추가 진행 섹션을 참조하십시오.
• View 행렬은 카메라 공간에서 조명 방향이 -Z가 되도록 월드를 회전시킵니다(튜토리얼 3 참조)
• Model 행렬은 원하는 대로 사용할 수 있습니다.

glm::vec3 lightInvDir = glm::vec3(0.5f,2,2);

 // Compute the MVP matrix from the light's point of view
 glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10,10,-10,10,-10,20);
 glm::mat4 depthViewMatrix = glm::lookAt(lightInvDir, glm::vec3(0,0,0), glm::vec3(0,1,0));
 glm::mat4 depthModelMatrix = glm::mat4(1.0);
 glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;

 // Send our transformation to the currently bound shader,
 // in the "MVP" uniform
 glUniformMatrix4fv(depthMatrixID, 1, GL_FALSE, &depthMVP[0][0])

쉐이더

이 패스 동안 사용되는 쉐이더는 매우 간단합니다. vertex 쉐이더는 균질 좌표에서 정점의 위치를 간단히 계산하는 통과 쉐이더입니다:

#version 330 core

// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;

// Values that stay constant for the whole mesh.
uniform mat4 depthMVP;

void main(){
 gl_Position =  depthMVP * vec4(vertexPosition_modelspace,1);
}

fragment 쉐이더는 단순하기 때문에 fragment의 깊이를 위치 0(즉, 깊이 텍스처)에 기록하기만 하면 됩니다.

#version 330 core

// Ouput data
layout(location = 0) out float fragmentdepth;

void main(){
    // Not really needed, OpenGL does it anyway
    fragmentdepth = gl_FragCoord.z;
}

Shadow Map을 렌더링하는 속도는 일반적으로 일반 렌더링보다 두 배 이상 빠릅니다. 깊이와 색상 대신 정밀도가 낮은 깊이만 기록되기 때문입니다. 메모리 대역폭은 GPU에서 가장 큰 성능 문제입니다.

결과

결과 텍스처는 다음과 같습니다.

어두운 색상은 작은 z를 의미합니다. 따라서 벽의 오른쪽 상단 모서리가 카메라 근처에 있습니다.

반대로 흰색은 z=1(동일한 좌표)을 의미하므로 매우 멀리 떨어져 있습니다.

Shadowmap 사용하기

기본 쉐이더

이제 평소의 쉐이더로 돌아갑니다. 계산하는 각 fragment에 대해 Shadow Map 뒤에 있는지 여부를 테스트해야 합니다.

이를 위해 Shadow Map을 만들 때 사용한 공간과 동일한 공간에서 현재 fragment의 위치를 계산해야 합니다. 따라서 일반적인 MVP 행렬로 한 번 변환하고 깊이 MVP 행렬로 한 번 변환해야 합니다.

하지만 약간의 속임수가 있습니다. 정점 위치에 깊이를 곱하면 MVP는 [-1,1]에 있는 균일한 좌표를 제공하지만 텍스처 샘플링은 [0,1]에서 수행해야 합니다.

예를 들어, 화면 중앙에 있는 fragment는 균일한 좌표로 (0,0)에 있을 것입니다. 그러나 질감 중간은 샘플링해야 하므로 UV는 (0.5,05)이어야 합니다.

이것은 fragment shader에서 직접 fetch 좌표를 조정하여 해결할 수 있지만, 단순히 좌표를 2(대각선 : [-1.1] -> [-0.5,0.5])로 나누고 변환하는 행렬(아래 행 : [-0.5,0.5]->[0,1])을 곱하는 것이 더 효율적입니다.

glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
glm::mat4 depthBiasMVP = biasMatrix*depthMVP;

이제 vertex 쉐이더를 작성할 수 있습니다. 이전과 동일하지만 1:1이 아닌 2개의 위치를 출력합니다:

• gl_Position 은 현재 카메라에서 볼 수 있는 정점의 위치입니다.
• ShadowCoord는 마지막 카메라(빛)에서 볼 수 있는 정점의 위치입니다.

// Output position of the vertex, in clip space : MVP * position
gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

// Same, but with the light's view matrix
ShadowCoord = DepthBiasMVP * vec4(vertexPosition_modelspace,1);

그런 다음 fragment 쉐이더는 매우 간단합니다:

• texture(shadowMap, ShadowCoord.xy).z 는 빛과 가장 가까운 빛을 차단하는 폐색자 사이의 거리입니다.
• ShadowCoord.z는 빛과 현재 fragment 사이의 거리입니다.

...따라서 현재 fragment가 가장 가까운 폐색자보다 멀리 있으면, 이것은 우리가 (해당 가장 가까운 폐색자의) 그림자에 있다는 것을 의미합니다.

float visibility = 1.0;
if ( texture( shadowMap, ShadowCoord.xy ).z  <  ShadowCoord.z){
    visibility = 0.5;
}

우리는 이 지식을 이용하여 음영을 수정해야 합니다. 물론 주변 색상은 수정되지 않습니다. 생활 속의 목적은 우리가 그림자 속에 있을 때도 들어오는 빛을 가짜로 만드는 것이기 때문입니다(또는 모든 것이 순수한 검은색일 것입니다)

color =
 // Ambient : simulates indirect lighting
 MaterialAmbientColor +
 // Diffuse : "color" of the object
 visibility * MaterialDiffuseColor * LightColor * LightPower * cosTheta+
 // Specular : reflective highlight, like a mirror
 visibility * MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5);

결과 - 쉐도우 아크네

다음은 현재 코드의 결과입니다. 분명히, 아이디어는 뛰어나지만 , 품질은 받아들일 수 없습니다.

이 이미지의 각 문제를 살펴보겠습니다.

코드에는 ShadowMap과 ShadowMap_simple의 두 가지 프로젝트가 있으며, 둘 중 더 마음에 드는 것으로 시작하세요.

간단한 버전은 위의 이미지만큼 품질이 좋지 않지만 이해하기가 더 쉽습니다.

문제점들

Shadow acne

가장 명백한 문제점은 shadow acne이다:

이 현상은 간단한 이미지로 쉽게 설명할 수 있습니다:

이에 대한 일반적인 "수정"은 error margin을 추가하는 것입니다. 현재 fragment의 depth(다시말해, 빛 공간)가 라이트맵 값에서 정말 멀리 떨어져 있는 경우에만 음영 처리합니다. 편향을 추가하여 이를 수행합니다:

float bias = 0.005;
float visibility = 1.0;
if ( texture( shadowMap, ShadowCoord.xy ).z  <  ShadowCoord.z-bias){
    visibility = 0.5;
}

결과물은 훨씬 나아집니다:

하지만, 여러분은 우리의 편견 때문에 땅과 벽 사이의 인공물이 더 나빠졌다는 것을 알아차릴 수 있습니다.

게다가, 0.005의 편향은 땅에서는 너무 많이 보이지만, 곡면에서는 충분하지 않습니다: 몇몇 인공물들은 실린더와 구에 남아 있습니다.

일반적인 접근 방식은 기울기에 따라 치우침을 수정하는 것입니다:

float bias = 0.005*tan(acos(cosTheta)); // cosTheta is dot( n,l ), clamped between 0 and 1
bias = clamp(bias, 0,0.01);

Shadow acne는 이제, 구부러진 표면에서도 사라졌습니다.

지오메트리에 따라 작동하거나 작동하지 않을 수 있는 또 다른 방법은 ShadowMap에서 뒷면만 렌더링하는 것입니다. 이것은 우리가 두꺼운 벽을 가진 특별한 기하학적 구조(다음 섹션 - Peter Panning 참조)를 갖도록 강요하지만, 적어도 acne는 그림자에 있는 표면에 있을 것입니다.

ShadowMap을 렌더링할 때 전면 삼각형을 잘라냅니다.

        // We don't use bias in the shader, but instead we draw back faces,
        // which are already separated from the front faces by a small distance
        // (if your geometry is made this way)
        glCullFace(GL_FRONT); // Cull front-facing triangles -> draw only back-facing triangles

그리고 씬(scene)을 렌더링할 때는 정상적으로 렌더링합니다(뒷면 절단)

         glCullFace(GL_BACK); // Cull back-facing triangles -> draw only front-facing triangles

이 방법은 편향 외에도 코드에 사용됩니다.

Peter Panning

우리는 더 이상 Shadow acne가 없지만, 여전히 잘못된 음영의 땅을 가지고 있고, 벽을 날아다니는 것처럼 보이게 합니다(이후 "피터 패닝"이라는 용어). 사실, 편향(bias)을 더하는 것은 상황을 더 악화시켰습니다.

이것은 매우 쉽게 고칠 수 있습니다. 얇은 기하학적 구조를 피하기만 하면 됩니다. 두 가지 이점이 있습니다.

• 먼저, 피터 패닝을 해결합니다. 기하학이 여러분의 편견보다 더 깊다면, 여러분은 준비가 다 된 것입니다.
• 두 번째로, 라이트맵을 렌더링할 때 후면 절단 기능을 설정할 수 있습니다. 왜냐하면 이제 벽의 다각형이 빛을 향하고 있기 때문입니다. 이 다각형은 뒷면 절단 기능을 사용하여 렌더링되지 않을 수 있습니다.

단점은 렌더링할 삼각형이 더 많다는 것입니다(프레임당 두 번!)

Aliasing

이 두 가지 방법에도 불구하고, 여러분은 그림자의 경계에 여전히 앨리어싱이 있다는 것을 알아차릴 것입니다. 즉, 한 픽셀은 흰색이고 다음 픽셀은 검은색입니다. 그 사이에 매끄러운 전환이 없습니다.

PCF

이를 개선하는 가장 쉬운 방법은 ShadowMap의 샘플러 유형을 Sampler2D 쉐이더로 변경하는 것입니다.

결과적으로 ShadowMap을 한 번 샘플링하면 하드웨어가 실제로 인접한 텍셀도 샘플링하고 모든 텍셀에 대해 비교를 수행하며 비교 결과의 이중 선형 필터링과 함께 [0,1]의 부동 소수점을 반환합니다.

예를 들어, 0.5는 두 개의 표본이 그림자에 있고 두 개의 표본이 빛에 있다는 것을 의미합니다.

필터링된 깊이 맵의 단일 샘플링과 동일하지 않습니다! 비교는 항상 true 또는 false를 반환합니다. PCF는 4 "true 또는 false"의 보간값을 제공합니다.

보시다시피 그림자 테두리는 매끄럽지만 그림자 맵의 텍스처는 여전히 보입니다.

Poisson Sampling

이 문제를 해결하는 쉬운 방법은 쉐도우 맵을 한 번이 아니라 N번 샘플링하는 것입니다. PCF와 함께 사용하면 N이 작더라도 매우 좋은 결과를 얻을 수 있습니다. 샘플 4개에 대한 코드는 다음과 같습니다:

for (int i=0;i<4;i++){
  if ( texture( shadowMap, ShadowCoord.xy + poissonDisk[i]/700.0 ).z  <  ShadowCoord.z-bias ){
    visibility-=0.2;
  }
}

poissonDisk는 예를 들어 다음과 같이 정의된 상수 배열입니다:

vec2 poissonDisk[4] = vec2[](
  vec2( -0.94201624, -0.39906216 ),
  vec2( 0.94558609, -0.76890725 ),
  vec2( -0.094184101, -0.92938870 ),
  vec2( 0.34495938, 0.29387760 )
);

이 방법은 통과할 쉐도우 맵 샘플 수에 따라 생성된 fragment가 다소 어두워집니다.

700.0 상수는 표본이 "확산"되는 정도를 정의합니다. 너무 적게 퍼뜨리면 다시 앨리어싱이 발생하고, 너무 많이 퍼뜨리면 밴딩이 발생합니다.*(이 스크린샷은 더 극적인 효과를 위해 PCF를 사용하지 않고 대신 16개의 샘플을 사용합니다.*

Stratified Poisson Sampling

픽셀마다 다른 샘플을 선택하여 이 밴딩을 제거할 수 있습니다.

두 가지 주요 방법이 있습니다 : Stratified Poisson 또는 Rotated Poisson

Stratified는 서로 다른 표본을 선택합니다. Rotated는 항상 같은 것을 사용하지만 랜덤 회전을 사용하여 서로 다르게 보입니다. 이 튜토리얼에서는 Stratified 버전만 설명하겠습니다.

이전 버전과의 유일한 차이점은 랜덤 인덱스로 poissonDisk를 인덱싱한다는 것입니다:

    for (int i=0;i<4;i++){
        int index = // A random number between 0 and 15, different for each pixel (and each i !)
        visibility -= 0.2*(1.0-texture( shadowMap, vec3(ShadowCoord.xy + poissonDisk[index]/700.0,  (ShadowCoord.z-bias)/ShadowCoord.w) ));
    }

다음과 같은 코드로 난수를 생성할 수 있으며,[0,1]에서 난수를 반환합니다:

    float dot_product = dot(seed4, vec4(12.9898,78.233,45.164,94.673));
    return fract(sin(dot_product) * 43758.5453);

우리의 경우 seed4는 i(4개의 서로 다른 위치에서 샘플을 채취할 수 있도록)와 ...의 조합이 됩니다.

gl_FragCord(화면의 픽셀 위치)또는 Position_worldspace를 사용할 수 있습니다.

        //  - A random sample, based on the pixel's screen location.
        //    No banding, but the shadow moves with the camera, which looks weird.
        int index = int(16.0*random(gl_FragCoord.xyy, i))%16;
        //  - A random sample, based on the pixel's position in world space.
        //    The position is rounded to the millimeter to avoid too much aliasing
        //int index = int(16.0*random(floor(Position_worldspace.xyz*1000.0), i))%16;

이렇게 하면 위의 그림과 같은 패턴이 사라지고 시각적 노이즈가 사라집니다.

그럼에도 불구하고 잘 수행된 노이즈는 종종 이러한 패턴보다 덜 불쾌합니다.

세 가지 구현에 대한 예는 tutorial16/ShadowMapping.fragmentshader 를 참조하십시오.

더 나아가기

이 모든 방법에도 불구하고, 우리의 그림자를 개선할 수 있는 많은 방법들이 있습니다.

가장 일반적인 것은 다음과 같습니다.

Early bailing

각 fragment에 대해 16개의 표본을 추출하는 대신(다시 말하면 많은 양) 4개의 멀리 있는 표본을 추출합니다.

만약 그들 모두가 빛이나 그림자 속에 있다면, 여러분은 16개의 샘플 모두가 같은 결과를 냈을 것이라고 생각할 수 있습니다: Early bailing. 만약 어떤 것들이 다르다면, 여러분은 아마도 그림자 경계에 있을 것이기 대문에 16개의 샘플이 필요합니다.

Spot lights

스포트라이트를 다루는 데는 변경 사항이 거의 필요하지 않습니다. 가장 확실한 것은 직교 투용 행렬을 원근 투영 행렬로 변경하는 것입니다.

glm::vec3 lightPos(5, 20, 20);
glm::mat4 depthProjectionMatrix = glm::perspective<float>(glm::radians(45.0f), 1.0f, 2.0f, 50.0f);
glm::mat4 depthViewMatrix = glm::lookAt(lightPos, lightPos-lightInvDir, glm::vec3(0,1,0));

같은 것이지만, orthographic frustum 대신에 perspective frustum을 사용합니다.

texture2Dproj 를 사용하여 원근 분할을 합니다.(자습서4- 행렬의 각주 참조)

두번째 단계는 쉐이더의 관점에서 고려하는 것입니다.(자습서 4- 행렬의 각주 참조). 간단히 말해서, 투시 투영 행렬은 실제로 어떤 투시도 하지 않습니다. 이 작업은 하드웨어에서 예상 좌표를 w로 나누어 수행합니다.

여기서, 우리는 쉐이더의 변형을 모방하기 때문에, 우리는 우리 자신을 분할하는 관점을 해야 합니다. 참고로, orthographic 행렬은 항상 w=1의 균질 벡터를 생성하므로 원근법을 생성하지 않습니다).

GLSL에서 이를 수행하는 방법이 있습니다. 두 번째줄은 내장 textureProj 함수를 사용하지만 두 방법 모두 정확하게 동일한 결과를 생성합니다.

if ( texture( shadowMap, (ShadowCoord.xy/ShadowCoord.w) ).z  <  (ShadowCoord.z-bias)/ShadowCoord.w )
if ( textureProj( shadowMap, ShadowCoord.xyw ).z  <  (ShadowCoord.z-bias)/ShadowCoord.w )

Point lights

동일하지만 depth 규브 맵을 사용합니다. 큐브 맵은 큐브의 각 면에 하나씩 있는 6개의 텍스처 세트입니다. 또한 표준 UV 좌표를 사용하지 않고 방향을 나타내는 3D 벡터를 사용하여 액세스 할 수 있습니다.

깊이는 공간의 모든 방향에 대해 저장되므로 점광 주위에 그림자가 드리울 수 있습니다.

여러개의 빛 혼합

알고리즘은 여러 개의 조명을 처리하지만 각 조명은 그림자 맵을 생성하기 위해 장면을 추가로 렌더링해야 합니다. Shadow를 적용할 때 엄청난 메모리가 필요하며 대역폭이 매우 빠르게 제한될 수 있습니다.

자동 빛 frustum

이 튜토리얼에서는 전체 장면을 포함하도록 손으로 만든 빛 frustum입니다. 이 제한된 예제에서는 이 작업이 작동하지만 이 작업은 피해야 합니다.

만약 당신의 지도가 1Km x 1Km이라면, 당신의 1024x1024 그림자 지도의 각 텍스트는 1평방미터를 차지할 것입니다. 이것은 형편 없습니다. 조명의 투영 행렬은 가능한한 타이트해야합니다.

스포트라이트의 경우 범위를 조정하여 쉽게 변경할 수 있습니다.

태양과 같은 방향 조명은 더 까다롭습니다. 그것들은 정말로 전체 장면을 비추죠. 광격자를 계산하는 방법은 다음과 같습니다:

1. 잠재적 그림자 수신기 또는 줄여서 PSR은 빛의 frustum, view frustum 및 장면 경계 상자에 동시에 속하는 객체 입니다. 이름에서 알 수 있듯이, 이 물체들은 음영을 받기 쉽습니다. 카메라와 빛으로 볼 수 있습니다.
2. 잠재적 그림자 캐스터(PCF)는 모두 잠재적 그림자 수신기이며, 그 사이에 있는 모든 물체(물체는 보이지 않지만 여전히 보이는 그림자를 드리울 수 있음)입니다.

따라서 빛 투영 행렬을 계산하려면 보이는 모든 객체를 가져와서 너무 멀리 있는 객체를 제거하고 경계 상자를 계산합니다. 이 경계 상자와 조명 사이에 있는 객체를 추가하고 새 경계 상자를 계산합니다(그러나 이번에는 조명 방향을 따라 정렬됨).

이러한 집합의 정확한 계산에는 볼록 껍질 교차점 계산이 포함되지만, 이 방법은 구현하기가 훨씬 쉽습니다.

이 방법을 사용하면 그림자 맵 해상도가 갑자기 증가하기 때문에 물치가 frustum에서 사라지면 팝핑이 발생합니다. 계단식 Shadow Map에는 이러한 문제가 없지만 구현하기가 더 어려우며 시간이 지남에 따라 값을 매끄럽게 하여 보정할 수 있습니다.

지수 shadow maps

지수 그림자 맵은 그림자에 있지만 빛 표면 근처에 있는 fragment가 실제로 "가운데 어딘가"라고 가정하여 앨리어싱을 제한하려고 합니다. 테스트가 더이상 이진법이 아니라는 점을 제외하면 이는 편향과 관련 있습니다. 빛이 있는 표면까지의 거리가 증가하면 fragment가 점점 어두워집니다.

이것은 명백히 부정행위이며, 두 물체가 겹칠 때 인공물이 나타날 수 있습니다.

빛-공간 원근법 shadow maps

LiSPSM은 카메라 근처에서 더 정확하게 하기 위해 빛 투영 행렬을 조정합니다. 이것은 "불안정한 frustra"의 경우에는 특히 중요합니다. 여러분은 방향을 바라지만, 스폿라이트는 반대 방향을 바라봅니다. 당신은 빛 근처, 즉 당신으로부터 멀리 떨어진 곳에 많은 그림자 지도 정밀도를 가지고 있고, 당신이 가장 필요로 하는 카메라 근처에 낮은 해상도를 가지고 있습니다.

그러나 LiSPSM은 구현하기가 까다롭습니다. 구현에 대한 자세한 내용은 레퍼런스를 참조하십시오.

계단식 shadow maps

CSM은 LiSPSM과 완전히 동일한 문제를 다루지만 다른 방식으로 처리합니다. 단순히 view frustum의 여러 부분에 대해 여러 개의(2-4) 표준 그림자 맵을 사용합니다.

첫 번째 것은 첫 번째 미터를 다루기 때문에 꽤 작은 구역에 대해서는 훌륭한 해상도를 얻을 수 있습니다. 다음 그림자 지도는 더 먼 물체를 다룹니다. 마지막 shadow map은 장면의 큰 부분을 다루지만, 관점 때문에 가장 가까운 구역보다 시각적으로 더 중요하지는 않을 것입니다.

계단식 쉐도우 맵은 작성 당시(2012년) 최고의 복잡성/품질 비율을 가지고 있습니다. 이것은 많은 경우에 선택의 해결책입니다.

결론

보시다시피, 그림자 지도는 복잡한 주제입니다. 매년 새로운 변형과 개선사항이 발표되고 있으며, 현재로서는 어떤 솔루션도 완벽하지 않습니다.

다행히, 제시된 대부분의 방법은 함께 혼합될 수 있습니다. 빛 공간 관점에서 계산식 shadow map을 PCF로 매끄럽게 만드는 것이 완벽하게 가능합니다.. 이 모든 기술을 사용하여 실험해 보십시오.

결론적으로, 저는 당신이 가능할 때마다 미리 계산된 라이트맵을 고수하고, 동적 객체에만 shadowmap을 사용할 것을 제안합니다. 그리고 두 가지의 시작적 품질이 동일한지 확인하십시오. 완벽한 정적 환경과 모양새가 좋지 않은 그림자가 있는 것도 좋지 않습니다.

Release v3.2

2023년 02월 24일

Gitbook을 통해서 Documentation을 업데이트를 진행하는 듯 함.

추가

*피코 4*

- 피코4에 대한 공식적인 지원을 추가함

*크롬북*

- 크롬북에 추가적인 지원을 추가함. 더 많은 정보

*호스트 제어*

- 호스트가 다른 사용자에 대한 VR 추적을 재설정하는 옵션이 추가됨. 더 많은 정보

- 호스트가 세션 또는 이벤트를 잠그거나 잠금 해제하여 다른 사용자가 참여할 수 있는지 여부를 제어하는 옵션을 추가함. 더 많은 정보

- 호스트가 환경 내의 지정된 영역으로 개별 사용자를 소환하는 옵션이 추가됨. 더 많은 정보

*아바타*

- VR 사용자가 손목 컨트롤을 통해 추적을 재설정할 수 있는 옵션이 추가됨. 더 많은 정보

*IP와 에셋 보호*

- LITE 사용자가 IFX 스냅샷을 저장할 수 있는 기능이 제거됨. 더 많은 정보

- 사용자가 기본적으로 꺼져 있는 스냅샷을 저장할 때 공유 IFX를 포함할지 여부를 제어하는 세션 설정이 추가됨. 더 많은 정보

*스크린 공유*

- 연결된 화면 외에 공유할 특정 응용프로그램을 선택할 수 있는 기능이 추가됨. 더 많은 정보

*녹음*

- 그룹 수준에서 기록 기능에 대한 액세스를 비활성화하는 옵션이 추가됨.

개선사항

*보안과 성능*

- 플랫폼의 안정성에 도움이 되는 중요한 업데이트 및 개선 사항을 적용함.

- 사용자가 일반적으로 사용되는 암호를 선택하지 못하도록 사용자 암호 만들기 기능이 향상됨.

- OWASP ASVS V4 지침에 따라 사용자가 암호를 표시하거나 숨길 수 있는 옵션이 추가됨.

- 암호 강도 표시기를 추가함.

*호스트 제어*

- VR 장치의 호스트에 대한 소환 프로세스를 개선하여 소환된 사용자가 직면할 방향을 변경할 수 있음. 더 많은 정보

*콘텐츠 에디터*

- 현재 선택한 개체에 대한 IFX 옵션을 표시하는 바로 가기로 O 키를 추가함.

- 응용프로그램에서 내용 작성자의 이름을 내용 편집기로 변경함.

- 프로그램에서 장면 이름이 시퀀스로 변경됨.

- 타임라인에서 재생 헤드가 다시 0으로 점프하는 대신 위치를 유지하도록 저장 프로세스를 개선함.

*포탈*

- 암호로 보호된 세션으로 이어지는 포털에 대한 지원이 추가됨. 사용자가 포털을 통과하려면 암호를 입력해야 함. 더 많은 정보

*이모지*

- Windows 장치의 사용자가 바로 가기 키를 통해 이모지를 활성화할 수 있는 옵션이 추가됨. 더 많은 정보

*오디오*

- 부재중 모드를 종료할 때 사용자의 마이크가 부재중 모드로 전환되기 전과 동일한 음소거 상태가 되도록 부재중 모드에 대한 음소거 규칙을 변경함.

- 사용자를 앉히거나 호출하거나 녹음할 때 카운트다운 오디오 경보의 볼륨을 보다 편안한 수준으로 낮춤.

*아바타*

- VR 기기가 아닌 사용자가 활성화할 수 있는 박수 및 손 올리기 애니메이션을 개선함.

*미디어*

- 동영상 검색 결과 페이지에 metadata 정보를 추가함.

*로컬라이제이션*

- 현지화된 텍스트의 배치 및 간격에 여러 개선사항을 적용함.

*웹 브라우저*

- 사용자가 세션 내 브라우저를 통해 부적절한 사이트에 액세스하지 못하도록 웹 사이트 필터링이 개선됨.

수정사항

*오디오*

- Windows 장치에서 디스플레이 레이아웃이 변경될 때 선택한 마이크 입력을 기본 설정으로 재설정하는 문제를 해결함.

- 사용자가 가입하는 동안 세션 위치가 변경된 경우 사용자의 음성 통신이 끊길 수 있는 문제를 해결함.

- 웹 브라우저를 공유할 때 Android 장치의 사용자가 Bluetooth 헤드폰을 통해 오디오를 손실할 수 있는 문제를 해결함.

*오디오*

- 피코 네오 3 또는 메타 퀘스트 2 헤드셋의 사용자가 다른 사용자의 기본 아바타가 다른 사용자가 away 모드에 들어갔을 때 바닥에 너무 가까이 있는 것을 보는 문제를 해결함.

- MyFace 자산 다운로드 지연으로 인해 우주복 장비 오버라이드 적용이 차단될 수 있는 문제를 해결함.

- 마이페이스를 적용하면 기본 아바타의 머리가 보이지 않을 수 있는 문제를 해결함.

- 사용자가 컨트롤러를 머리 가까이 가져갔을 때 아바타의 팔이 비현실적으로 회전하는 문제를 해결함.

*콘텐츠 에디터*

- Windows 장치에서 C키를 눌러 필드에 텍스트를 입력하면 컨트롤 오버레이가 켜지거나 꺼지는 문제를 해결함.

- 시간 표시 막대를 수직으로 스크롤할 때 시간 표시 막대의 새 위치로 개체 끌기 수정.

- 녹화에서 캡처된 미디어가 루프에서 처음 몇 초만 재생되는 문제를 해결함.

- 시간으로 건너뛰기 IFX의 시간 값 필드에 대한 변경 내용이 저장되지 않도록 할 수 있는 문제를 해결함.

- 실행 취소 옵션을 사용하면 이미지 IFX와 같은 개체가 눈에 띄게 깜박이기 시작할 수 있는 문제를 해결함.

- 개체에 적용된 변환이 실행 취소 기록에 추가되지 않은 문제를 해결하여 실행 취소 옵션을 사용하면 해당 작업이 무시됨.

- 시퀀스를 저장하고 다시 로드할 때까지 Cloud File Manager를 통해 로드된 오디오 파일이 들리지 않는 문제를 해결함.

- 트리거된 효과를 대화형 IFX에 추가하는 기능이 복원됨.

- 비디오 화면(플랫 외부 URL) IFX의 모양을 수정하여 중앙에 표시된 투명 스트립을 제거함.

*이모지*

- 사용자가 이모지를 활성화할 수는 없지만 이모지 패널에 대한 액세스가 이모지가 비활성화된 세션으로 넘어갈 수 있는 문제를 해결함.

*이벤트*

- 사용자가 이벤트를 종료한 후 다시 시작할 수 없도록 지연시키는 버그를 수정함.

*로컬라이제이션*

- 일부 언어에 대한 누락된 번역이 추가됨.

- 사용자가 PC VR 장치에서 바탕 화면을 공유할 때 일부 언어에 대해 나타나는 중첩 텍스트를 수정함.

*미디어*

- 미디어를 재생할 때 MacOS 장치의 사용자에게 윙윙거리는 소리가 들릴 수 있는 문제를 해결함.

- 360 비디오 룸에서 360 비디오를 볼 때 공유 화면 페이지에 겹치는 이미지가 나타나는 문제를 해결함.

- 공유된 파워포인트 프레젠테이션을 포함한 녹화 문제를 해결함. 사용자가 미디어 화면 앞에 다른 아바타가 움직이는 것을 본다면 해당 아바타는 시각적인 아티팩트를 뒤에 남깁니다.

*개인 경계*

- 아바타와 동시에 사용자의 태블릿이 사라지는 것을 방지하는 문제를 해결함.

*레코딩*

- 기록이 IFX로 로드된 후 세션에 참여한 사용자가 기록을 볼 수 없는 문제를 해결함.

*스냅샷*

- 이름이 변경된 IFX 스냅샷이 세션에 로드될 때 여전히 원래 이름을 표시하는 문제를 해결함.

*스티키 노트*

- Windows 및 MacOS 장치에서 이전에 입력한 텍스트를 중간에 입력할 수 없는 문제를 해결함.

*유저 인터페이스*

- 아바타가 움직이는 플랫폼이나 객체에 있는 동안 사용자가 세션 내 메뉴의 일부와 상호 작용할 수 없는 문제를 해결함.

- 로딩 환경에서 여러 줄 제목이 부분적으로 끊기는 문제를 해결함.

- 아바타의 머리 위에 나타나는 하드 뮤트 아이콘으로 인해 물체와 풍경을 통해 볼 수 있는 문제를 해결함.

- 미디어 로드 스피너의 일부를 통해 사용자 인터페이스가 표시되는 문제를 해결함.

- 사용자가 저장된 비디오 링크를 검색할 때 나타나는 가상 키보드의 제목을 수정함.

- 비디오 링크 또는 웹 링크를 로드하는 사용자에 의해 콘텐츠 재생이 중단된 경우 콘텐츠가 재생 중이라는 표시가 계속 표시 되는 문제를 해결함.

*VR 헤드셋*

- PICO 및 VIVE 헤드셋의 세션 내 메뉴와 상호 작용할 때 아바타의 손이 계속 보이는 문제를 해결함.

- PICO 및 VIVE 헤드셋에서 핸드 컨트롤러가 보이지 않는 문제를 해결함.

- PICO 헤드셋의 사용자가 포털로 순간이동 할 수 없는 문제를 해결함.

*공지*

- ENGAGE XR은 더이상 오큘러스 퀘스트 1, 피코 네오 2, VIVE 포커스 플러스 장치를 포함하여 2020년 이전에 출시된 독립형 VR 헤드셋을 지원하지 않습니다. 하드웨어 제조사의 지원이 계속 철회되고 현대 VR의 수요가 증가하고 있기 때문입니다. 이러한 장치를 사용하는 사용자는 계속해서 참여에 액세스할 수는 있지만 안정성이나 성능은 보장할 수 없습니다.

Release v3.2.1

수정사항

*로그인*

- PC 사용자가 로그인한 직후에 다른 장치에 로그인했다는 잘못된 오류 메시지와 함꼐 응용 프로그램에서 로그아웃할 수 있는 문제를 해결했습니다.

- 사람들이 자신의 VIVE 계정을 사용하여 로그인하지 못하게 하는 문제를 해결했습니다.

원본 - https://learnopengl.com/Getting-started/Creating-a-window

멋진 그래픽을 만들기 전에 먼저 해야 할 일은 OpenGL 컨텐스트와 어플리케이션 창을 만들어서 끌어오는 것입니다.

그러나 이러한 작업은 운영 체제마다 다르며 OpenGL은 의도적으로 이러한 작업에서 추상화하려고 합니다.

즉, 창을 만들고, 컨텍스트를 정의하고, 사용자 입력을 직접 처리해야 합니다.

다행히도, 우리가 찾는 기능을 제공하는 꽤 많은 라이브러리가 있으며, 일부 라이브러리는 특히 OpenGL을 목표로 합니다.

이러한 라이브러리는 운영 체제별 작업을 모두 저장하고 렌더링할 수 있는 창과 OpenGL 컨텍스트를 제공합니다.

GLUT, SDL, SFML, GLFW 등이 유명합니다.

LearnOpenGL에서는 GLFW를 사용합니다.

대부분의 설정은 GLFW의 설정과 유사하므로 다른 라이브러리를 자유롭게 사용하십시오.

GLFW

GLFW는 C로 작성된 라이브러리로, 특히 OpenGL을 대상으로 합니다.

GLFW는 화면에 상품을 렌더링하는데 필요한 최소한의 필수품을 제공합니다.

이를 통해 OpenGL 컨텍스트를 만들고, 창 매개 변수를 정의하고, 사용자 입력을 처리할 수 있으며, 이는 우리의 목적에 충분합니다.

이 장과 다음 장의 추점은 GLFW를 가동하여 OpenGL 컨텍스트를 적절하게 생성하고 우리가 장난칠 수 있는 간단한 창을 표시하도록 하는 것입니다.

이 창에서는 GLFW 라이브러리를 검색, 구축 및 연결하는 단계별 접근 방식을 사용합니다.

이 문서에서는 Microsoft Visual Studio 2019 IDE를 사용합니다(더 최신 Visual Studio 버전에서도 프로세스는 동일합니다).

Visual Studio(또는 이전 버전)를 사용하지 않는 경우 대부분의 다른 IDE에서도 프로세스가 유사합니다.

GLFW 빌드하기

GLFW는 웹 페이지의 다운로드 페이지에서 얻을 수 있습니다.

GLFW는 이미 2019년까지 Visual Studio 2012용으로 미리 컴파일된 이진파일과 헤더 파일을 가지고 있지만, 완전성을 위해 소스 코드에서 GLFW를 직접 컴파일할 것입니다.

이것은 모든 라이브러리가 미리 컴파일된 바이너리를 사용할 수 있는 것은 아니기 때문에 오픈 소스 라이브러리를 직접 컴파일하는 과정에 대한 느낌을 주기 위한 것입니다.

소스 패키지를 다운로드해 보겠습니다.

소스 패키지를 다운로드한 후 압출을 풀고 내용을 엽니다.

우리는 몇 가지 품목에만 집중할 것입니다.

• 컴파일의 결과인 라이브러리
• include 폴더

소스 코드에서 라이브러리를 컴파일하면 결과 라이브러리가 CPU/OS에 완벽하게 맞춤화되어 고급 사전 컴파일된 바이너리가 항상 제공되는 것은 아닙니다(시스템에서 사전 컴파일된 바이너리를 사용할 수 없는 경우도 있음).

그러나 오픈 월드에 소스 코드를 제공할 때의 문제는 모든 사람이 자신의 애플리케이션을 개발하기 위해 동일한 IDE 또는 빌드 시스템을 사용하지 않는다는 것입니다.

즉, 제공된 프로젝트/솔루션 파일이 다른 사용자의 설정과 호환되지 않을 수 있습니다.

따라서 사용자는 지정된 .c .cpp 및 .h .hpp 파일을 사용하여 자신만의 프로젝트/솔루션을 설정해야 합니다.

이는 번거러운 작업입니다.

바로 이러한 이유로 Cmake라는 도구가 있습니다.

CMake

CMake는 미리 정의된 CMake 스크립트를 사용하여 소스 코드 파일 모음에서 사용자가 선택한 프로젝트/솔루션 파일(예: Visual Studio, 코드::블럭, Eclipse)을 생성할 수 있는 도구입니다.

이를 통해 라이브러리를 컴파일하는 데 사용할 수 있는 GLFW의 소스 패키지에서 Visual Studio 2019 프로젝트 파일을 생성할 수 있습니다.

먼저 다운로드 페이지에서 다운로드할 수 있는 CMake를 다운로드하여 설치해야 합니다.

CMake가 설치되면 명령줄 또는 GUI를 통해  CMake를 실행하도록 선택할 수 있습니다.

너무 복잡하지 않기 때문에 GUI를 사용할 예정입니다.

CMake에는 이진 파일에 대한 소스 코드 폴더와 대상 폴더가 필요합니다.

소스 코드 폴더의 경우 다운로드한 GLFW 소스 패키지의 루트 폴더를 선택하고 빌드 폴더의 경우 새 디렉토리 빌드를 만든 다음 해당 디렉토리를 선택합니다.

소스 및 대상 폴더를 설정했으면 구성 단추를 클릭하여 CMake가 필요한 설정과 소스 코드를 읽을 수 있도록 합니다.

그런 다음 프로젝트의 생성자를 선택해야 하며 Visual Studio 2019를 사용하기 때문에 Visual Studio 16 옵션을 선택합니다(Visual Studio 2019는 Visual Studio 16으로도 알려져 있습니다).

그런 다음 CMake는 결과 라이브러리를 구성하기 위해 가능한 빌드 옵션을 표시합니다. 설정을 기본값으로 유지하고 구성을 다시 클릭하여 설정을 저장할 수 있습니다.

셋팅이 설정되면 생성을 클릭하면 결과 프로젝트 파일이 빌드 폴더에 생성됩니다.

Compilation(모음집)

빌드 폴더에서 GLFW.sin 파일을 찾을 수 있으며 Visual Studio 2019에서 엽니다.

CMake는 이미 적절한 구성 설정이 포함된 프로젝트 파일을 생성했기 때문에 솔루션을 구축하기만 하면 됩니다.

CMake는 64비트 라이브러리로 컴파일할 수 있도록 솔루션을 자동으로 구성했어야 합니다.

이제 빌드 솔루션을 선택하십시오.

이렇게 하면 glfw3.lib라는 이름의 build/src/debug 에서 찾을 수 있는 컴파일된 라이브러리 파일이 제공됩니다.

라이브러리를 생성한 후에는 IDE가 라이브러리와 OpenGL 프로그램의 포함 파일을 찾을 수 있는 위치를 알고 있는지 확인해야 합니다.

이 작업에는 두 가지 일반적인 접근 방식이 있습니다:

1. IDE/컴파일러에서 /lib 와 /include 폴더를 찾아서 GLFW의 include 폴더의 내용을 IDE의 /include 폴더에 추가하고 마찬가지로 glfw3.lib를 IDE의 /lib 폴더에 추가합니다. 이 방법은 효과가 있지만 권장되는 방법은 아닙니다. 라이브러리를 추적하고 파일을 포함하는 것은 어렵고 IDE/컴파일러를 새로 설치하면 이 프로세스를 처음부터 다시 수행해야 합니다.
2. 또 다른 방법은 IDE/compiler 에서 참조할 수 있는 타사 라이브러리의 모든 header files/libraries를 포함하는 디렉터리 세트를 원하는 위치에 새로 만드는 것입니다. 예를 들어 OpenGL 프로젝트의 모든 라이브러리 및 헤더 파일을 각각 저장하는 Libs 및 Include 폴더가 포함된 단일 폴더를 만들 수 있습니다. 이제 모든 타사 라이브러리가 단일 위치(여러 컴퓨터에서 공유할 수 있음) 내에 구성됩니다. 그러나 새 프로젝트를 생성할 때마다 IDE에 해당 디렉토리를 찾을 수 있는 위치를 알려줘야 합니다.

필요한 파일이 원하는 위치에 저장되면 첫 번째 OpenGL GLFW 프로젝트를 시작할 수 있습니다.

우리의 첫번째 프로젝트

먼저 Visual Studio를 열고 새 프로젝트를 만들어 보겠습니다. 여러 옵션이 지정된 경우 C++를 선택하고 빈 프로젝트를 선택합니다(프로젝트에 적합한 이름을 지정하는 것을 잊지 마십시오). 64비트로 모든 작업을 수행할 예정이며 프로젝트의 기본값은 32비트이므로 상단의 디버그 옆에 있는 드롭다운을 x86에서 x64로 변경해야 합니다.

이 작업이 완료되면 최초의 OpenGL 애플리케이션을 만들 수 있는 작업 공간을 확보할 수  있습니다!

링킹

프로젝트가 GLFW를 사용하기 위해서 라이브러리와 우리의 프로젝트를 연결해야 합니다. 이는 링커 설정에서 glfw3.lib를 사용할 것을 지정함으로써 수행할 수 있지만, 타사 라이브러리를 다른 디렉토리에 저장하기 때문에 우리 프로젝트는 glfw3.lib를 어디서 찾을 수 있는지 아직 모릅니다. 따라서 먼저 이 디렉토리를 프로젝트에 추가해야 합니다.

IDE가 라이브러리를 찾고 파일을 포함해야 할 때 이 디렉토리를 고려하도록 지시할 수 있습니다. 솔루션 탐색기에서 프로젝트 이름을 마우스 오른쪽 버튼으로 클릭한 다음 아래 이미지와 같이 VC++ 디렉토리로 이동합니다.

그런 다음 사용자 자신의 디렉토리를 추가하여 프로젝트가 검색할 위치를 알 수 있도록 할 수 있습니다. 텍스트에 수동으로 삽입하거나 적절한 위치 문자열을 클릭하고 <편집> 옵션을 선택하면 됩니다. 라이브러리 디렉토리와 포함 디렉토리 모두에 대해 이 작업을 수행합니다.

여기서 원하는 만큼 디렉토리를 추가할 수 있으며, 이때부터 IDE는 라이브러리 및 헤더 파일을 검색할 때 해당 디렉터리도 검색합니다. GLFW의 Include 폴더가 포함되는 즉시 <GLFW/..>를 포함하여 GLFW의 모든 헤더 파일을 찾을 수 있습니다. 라이브러리 디렉토리도 마찬가지입니다.

VS가 이제 필요한 모든 파일을 찾을 수 있으므로 Linker 탭으로 이동하여 다음과 같이 입력하면 GLFW를 프로젝트에 연결할 수 있습니다.

그런 다음 라이브러리에 연결하려면 링커에 대한 라이브러리 이름을 지정해야 합니다. 라이브러리 이름이 glfw3.lib이므로 이를 Additional Dependencies 필드에 추가합니다(수동 또는 <Edit> 옵션 사용) 그리고 그 시점부터 우리가 컴파일할 때 GLFW가 연결될 것입니다. GLFW 외에도 OpenGL 라이브러리에 링크 항목을 추가해야 하지만 운영 체제에 따라 다를 수 있습니다.

Windows에서의 OpenGL

Windows에서 OpenGL 라이브러리 opengl32.lib는 Visual Studio를 설치할 때 기본적으로 설치할 때 기본적으로 설치되는 Microsoft SDK와 함께 제공됩니다. 이 장에서는 VS 컴파일러를 사용하고 윈도우에 있으므로 링커 설정에 opengl32.lib를 추가합니다. OpenGL 라이브러리의 64비트 등가는 32비트 등가와 마찬가지로 opengl32.lib라고 합니다.

Linux에서의 OpenGL

Linux 시스템에서는 링커 설정에 -IGL을 추가하여 libGL.so 라이브러리에 연결해야 합니다. 라이브러리를 찾을 수 없는 경우 Mesa, NVidia 또는 AMD dev 패키지를 설치해야 할 수 있습니다.

그런 다음 GLFW 및 OpenGL 라이브러리를 모두 링커 설정에 추가하면 다음과 같이 GLFW의 헤더 파일을 포함 할 수 있습니다.

이것으로 GLFW의 설정 및 구성이 완료되었습니다.

GLAD

아직 한 가지 더 해야 할 일이 있기 때문에 아직 거기까지는 이르지 못했습니다. OpenGL은 실제로 표준/사양에 불과하므로 특정 그래픽 카드가 지원하는 드라이버에 이 사양을 구현하는 것은 드라이버 제조업체에 달려 있습니다. 다양한 버전의 OpenGL 드라이버가 있기 때문에 컴파일 시 대부분의 기능 위치를 알 수 없으며 런타임에 쿼리해야 합니다. 그런 다음 필요한 기능의 위치를 검색하여 나중에 사용할 수 있도록 기능 포인터에 저장하는 것이 개발자의 작업입니다. 이러한 위치 검색은 OS별로 다릅니다. Windows에서는 다음과 같이 표시됩니다.

코드가 복잡해 보이고 아직 선언되지 않은 각 기능에 대해 이를 수행하는 것은 번거러운 프로세스입니다. 감사하게도, GLAD와 같이 인기 있고 최신인 라이브러리들이 있습니다.

GLAD 설정하기

GLAD는 우리가 이야기한 모든 번거러운 작업을 관리하는 오픈 소스 라이브러리입니다. GLAD는 대부분의 일반적인 오픈 소스 라이브러리와 약간 다른 구성 설정을 가지고 있습니다. GLAD는 어떤 버전의 OpenGL에 대해 해당 버전에 따라 모든 관련 OpenGL 기능을 정의하고 로드할 것인지를 GLAD에 알려줄 수 있는 웹 서비스를 사용합니다.

GLAD 웹 서비스로 이동하여 언어가 C++로 설정되어 있는지 확인하고 API 섹션에서 3.3이상의 OpenGL 버전을 선택합니다. 또한 프로파일이 Core로 설정되어 있고 Generate a loader 옵션이 선택되어 있는지 확인합니다.

확장명을 무시하고 생성을 클릭하여 결과 라이브러리 파일을 생성합니다.

지금쯤 GLAD는 두 개의 포함 폴더가 포함된 zip 파일과 하나의 glad.c 파일을 제공했어야 합니다. 포함 폴더(glad 및 KHR)를 모두 포함 디렉터리에 복사하고(또는 이 폴더를 가리키는 항목을 추가합니다) glad.c 파일을 프로젝트에 추가합니다.

이전 단계를 수행한 후에는 파일 위에 다음 포함 지시문을 추가할 수 있습니다.

컴파일 버튼을 눌러도 오류가 발생하지 않으므로 다음 장에서 GLFW와 GLAD를 사용하여 OpenGL 컨텍스트를 구성하고 창을 생성하는 방법에 대해 설명합니다. 포함 및 라이브러리 디렉토리가 모두 올바르고 링커 설정의 라이브러리 이름이 해당 라이브러리와 일치하는지 확인하십시오.

원본 - https://learnopengl.com/Getting-started/OpenGL

여정을 시작하기 전에 먼저 OpenGL이 실제로 무엇인지 정의해야 합니다.

OpenGL은 주로 그래픽과 이미지를 조작하는데 사용할 수 있는 많은 기능을 제공하는 API(Application Programming Interface)로써 후보로 거론됩니다.

그러나 OpenGL 자체는 API가 아니라 크로노스 그룹이 개발하고 유지 관리하는 사양에 불과합니다.

OpenGL 사양은 각 기능의 결과/출력과 수행 방법을 정확하게 명시합니다.

그런 다음 이 기능이 어떻게 작동해야 하는지에 대한 해결책을 마련하는 것은 이 사양을 구현하는 개발자에게 달려있습니다.

OpenGL 사양에는 구현 세부 정보이 나와 있지 않으므로, 실제 개발된 OpenGL 버전은 결과가 사양과 일치하는 한(따라서 사용자에게 동일한) 다른 구현을 허용합니다.

실제 OpenGL 라이브러리를 개발하는 사람들은 대개 그래픽 카드 제조업체입니다.

구입한 각 그래픽 카드는 해당 카드용 특별히 개발된 OpenGL 버전인 특정 OpenGL 버전을 지원합니다.

Apple 시스템을 사용할 때 OpenGL 라이브러리는 Apple이 직접 관리하며 Linux 아래에는 그래픽 공급업체의 버전과 이러한 라이브러리에 대한 애호가의 적응이 결합되어 있습니다.

이는 OpenGL이 하지 말아야 할 이상한 동작을 보일 때마다 그래픽 카드 제조업체(또는 라이브러리를 개발/유지 관리한 사람)의 잘못일 가능성이 높다는 것을 의미합니다.

Khronos는 모든 OpenGL 버전에 대한 모든 사양 문서를 공개적으로 호스팅합니다.

관심 있는 독자는 여기에서 버전 3.3의 OpenGL 사양(우리가 사용할 버전)을 찾을 수 있습니다.

이 사양은 OpenGL의 세부 사항을 자세히 살펴보고 싶다면 좋은 읽을거리입니다(구현이 아닌 결과만 설명합니다).

또한 사양은 기능의 정확한 작동을 찾는데 유용한 참고 자료를 제공합니다.

코어 프로파일 vs 즉시 모드(고정 함수 파이프라인)

옛날에는 OpenGL을 사용하는 것은 그래픽을 그리기 위한 사용하기 쉬운 방법인 즉시 모드(고정 함수 파이프라인이라고도 함)로 개발하는 것을 의미했습니다.

OpenGL의 대부분의 기능은 라이브러리 안에 숨겨져 있었고 개발자들은 OpenGL이 계산을 수행하는 방식을 크게 통제하지 못했습니다.

개발자들은 결국 더 많은 유연성을 원했고, 시간이 지남에 따라 사양이 더 유연해졌고, 개발자들은 그들의 그래픽을 더 많이 통제하게 되었습니다.

고정 함수 파이프라인을 사용하는 것은 정말 사용하기 쉽고 이해하기 쉽지만, 또한 매우 비효율적입니다.

이러한 이유로 이 사양은 버전 3.2 이후 즉시 모드 기능을 더 이상 사용하지 않기 시작했으며 개발자들이 OpenGL의 코어 프로파일 모드로 개발하도록 동기를 부여하기 시작했습니다.

이 모드는 오래된 모든 사용되지 않는 기능을 제거한 OpenGL의 사양의 한부분입니다.

OpenGL의 핵심 프로파일을 사용할 때 OpenGL은 현대적 관행을 사용하도록 강요합니다.

OpenGL에서 사용되지 않는 함수 중 하나를 사용하려고 할 때마다 OpenGL에서 오류가 발생하고 그리기가 중지됩니다.

현대적인 접근법을 배우는 것의 장점은 그것이 매우 유연하고 효율적이라는 것입니다.

하지만, 그것은 또한 배우기가 더 어렵습니다. 고정 함수 파이프라인은 OpenGL이 수행한 실제 작업에서 상당히 많은 부분을 추상화했으며 학습하기는 쉬웠지만 실제로 OpenGL이 어떻게 작동하는지 파악하기는 어려웠습니다.

현대적인 접근 방식은 개발자가 OpenGL과 그래픽 프로그래밍을 진정으로 이해해야 하며, 다소 어렵긴 하지만 훨씬 더 많은 유연성과 효율성, 그리고 가장 중요한 것은 그래픽 프로그래밍에 대한 훨씬 더 나은 이해를 가능하게 합니다.

이것은 또한 이 책이 핵심 프로필 OpenGL 버전 3.3에 맞춰진 이유입니다. 비록 그것이 더 어렵지만, 그것은 노력할 가치가 있습니다.

현재 OpenGL 4.6을 작성하는 시점에서 상위 버전의 OpenGL을 선택할 수 있습니다.

OpenGL 4.6이 출시된 상태에서 OpenGL 3.3을 제가 선택한 이유는 무엇일까요?

그 질문에 대한 대답은 비교적 간단합니다. 3.3 이후 버전의 모든 OpenGL은 OpenGL의 핵심 메커니즘을 변경하지 않고 OpenGL에 유용한 기능을 추가합니다.

새로운 버전은 동일한 작업을 수행하는 데 약간 더 효율적이거나 유용한 방법을 도입할 뿐입니다.

그 결과 모든 개념과 기술이 최신 OpenGL 버전에서 동일하게 유지되므로 OpenGL 3.3을 학습하는 것이 완벽하게 유효합니다.

언제든지 준비가 되었거나 경험이 풍부하면 최신 OpenGL 버전의 특정 기능을 쉽게 사용할 수 있습니다.

일부 챕터에서는 다음과 같이 기록된 보다 현대적인 기능을 확인할 수 있습니다.

확장

OpenGL의 큰 특징은 확장 기능을 지원한다는 것입니다.

그래픽 회사에서 렌더링을 위한 새로운 기술이나 새로운 대규모 최적화를 제안할 때마다 드라이버에 구현된 확장 기능에서 종종 발견됩니다.

응용프로그램이 실행되는 하드웨어가 이러한 확장을 지원하는 경우 개발자는 확장에서 제공하는 기능을 사용하여 보다 고급 또는 효율적인 그래픽을 구현할 수 있습니다.

이러한 방식으로 그래픽 개발자는 확장 기능이 그래픽 카드에서 지원되는지 확인하기만 하면 OpenGL이 향후 버전에 기능을 포함할 떄까지 기다리지 않고도 이러한 새로운 렌더링 기술을 사용할 수 있습니다.

종종 확장이 인기가 있거나 매우 유용한 경우 나중에 OpenGL 버전의 일부가 됩니다.

개발자는 이러한 확장을 사용하기 전(또는 OpenGL 확장 라이브러리를 사용하기 전) 사용 가능한 확장이 있는지 문의해야 합니다.

이를 통해 개발자는 확장을 사용할 수 있는지 여부에 따라 더 나은 작업 또는 더 효율적인 작업을 수행할 수 있습니다.

예를 들어, OpenGL이 삼각형 대신 선을 그리고 싶다고 말할 때마다 OpenGL이 그리는 방법을 설정하는 일부 컨텐스트 변수를 변경하여  OpenGL의 상태를 변경합니다.

OpenGL에 선을 그어야 한다고 말해 컨텍스트를 변경하는 즉시 다음 그리기 명령은 삼각형 대신 선을 그립니다.

OpenGL에서 작업할 때 컨텍스트를 변경하는 여러 상태 변경 기능과 OpenGL의 현재 상태를 기반으로 일부 작업을 수행하는 여러 상태 사용 기능을 만나게 됩니다.

OpenGL이 기본적으로 하나의 대형 상태 시스템이라는 것을 기억하는 한, 대부분의 기능은 더 의미가 있을 것입니다.

오브젝트

OpenGL 라이브러리는 C로 작성되어 있으며 다른 언어로 많은 파생을 허용하지만 핵심적으로는 C라이브러리로 남아 있습니다.

C 언어 구조 중 많은 부분이 다른 고급 언어로 잘 번역되지 않기 때문에 OpenGL은  몇 가지 추상화를 염두에 두고 개발되었습니다.

이러한 추상화 중 하나는 OpenGL의 객체입니다.

OpenGL의 개체는 OpenGL 상태의 하위 집합을 나타내는 옵션 모음입니다.

예를 들어, 도면 창의 설정을 나타내는 객체를 사용할 수 있습니다. 그런 다음 객체의 크기, 지원되는 색상 수 등을 설정할 수 있습니다.

그런 다음 객체의 크기, 지원되는 색상 수 등을 설정할 수 있습니다.

물체를 C와 같은 구조로 시각화할 수 있습니다.

객체를 사용하고자 할 때마다 일반적으로 다음과 같이 보입니다(OpenGL의 컨텍스트가 큰 구조로 시각화됨)

이 작은 코드 조각은 OpenGL로 작업할 때 자주 볼 수 있는 워크플로우입니다.

먼저 개체를 만들고 참조를 ID로 저장합니다(실제 개체의 데이터는 씬 뒤에 저장됨).

그럼 다음 개체(ID 사용)를 컨텐스트의 대상 위치에 바인딩합니다(예: 창 개체 대상 위치는 GL_WINDOW_TARGET으로 정의됨).

다음으로 창 옵션을 설정하고 마지막으로 창 대상의 현재 개체 ID를 0으로 설정하여 개체의 바인딩을 해제합니다.

설정한 옵션은 objectId에서 참조하는 개체에 저장되고 개체를 GL_WINDOW_TARGET에 다시 바인딩하는 즉시 복원됩니다.

이러한 개체를 사용하면 응용 프로그램에서 둘 이상의 개체를 정의하고 옵션을 설정할 수 있으며 OpenGL의 상태를 사용하는 작업을 시작할 때마다 원하는 설정으로 개체를 바인딩할 수 있습니다.

예를 들어 3D 모델 데이터(집 또는 캐릭터)의 컨테이너 개체 역할을 하는 개체가 있으며, 이 중 하나를 그리고 싶을 때마다 우리는 우리가 그릴 모델 데이터가 들어 있는 개체를 바인딩합니다(이러한 개체에 대한 옵션을 먼저 만들고 설정했습니다).

객체가 여러 개 있으면 많은 모델을 지정할 수 있고 특정 모델을 그리고 싶을 때마다 모든 옵션을 다시 설정하지 않고 해당 객체를 그리기 전에 간단히 바인딩할 수 있습니다.

시작하자

이제 OpenGL의 사양과 라이브러리, OpenGL이 후드 아래에서 어떻게 작용하는지, 그리고 OpenGL이 사용하는 몇 가지 사용자 지정 기술에 대해 알아봤습니다.

모든 것을 이해하지 못했더라도 걱정하지 마십시오.

이 책에서는 각 단계를 통해 OpenGL을 제대로 파악할 수 있는 충분한 예를 볼 수 있습니다.

추가 자료들

• opengl.org : OpenGL의 공식 웹사이트입니다.
• OpenGL registry : 모든 OpenGL 버전에 대한 OpenGL 사양 및 확장을 호스트합니다.

원본 페이지 - https://learnopengl.com/Introduction

당신이 이 페이지를 방문한 것은 컴퓨터 그래픽의 내적인 작용을 배우고 멋진 이들이 하는 모든 것을 혼자서 하고 싶을 것이다.

혼자서 무언가를 하는 것은 매우 재미있고, 지략이 풍부하며, 그래픽 프로그래밍에 대한 큰 이해를 준다.

그러나 시작하기 전에 고려해야 할 몇 가지 항목이 있습니다.

전제조건

OpenGL은 자체 플랫폼이 아닌 그래픽 API이기 때문에 동작하기 위한 언어가 필요하며 선택 언어는 C++입니다.

따라서 이 장들을 위해서는 C++ 프로그래밍 언어에 대한 적절한 지식이 필요합니다.

하지만, 필요한 경우 고급 C++ 주제를 포함하여 사용되는 대부분의 개념을 설명하려고 노력할 것입니다.

따라서 C++ 전문가가 될 필요는 없지만 "Hello World" 프로그램 이상의 것을 만들 수 있어야 합니다.

C++에 대한 경험이 많지 않다면 www.learncpp.com  에서 무료 튜토리얼을 추천합니다.

또한, 도중에 수학 (선형 대수학, 기하학, 삼각법)을 사용할 것이고 필요한 수학의 모든 필수 개념을 설명하려고 노력할 것입니다.

하지만 저는 수학자가 아니기 때문에 설명이 이해하기 쉽더라도 불완전할 가능성이 높습니다.

그래서 필요한 경우에는 자료를 보다 완벽하게 설명할 수 있는 좋은 자료에 대한 지침을 제공할 것입니다.

OpenGl로의 여정을 시작하기 전에 필요한 수학적 지식에 대해 두려워하지 마십시오.

거의 모든 개념은 기본적인 수학적 배경으로 히애할 수 있습니다.

가능한 한 수학을 최소화하도록 노력하겠습니다.

대부분의 기능은 사용법을 알고 있는 한 모든 수학을 이해할 필요조차 없습니다.

구조

Learn OpenGL은 여러 개의 일반적인 섹션으로 나뉩니다.

각 섹션에는 서로 다른 개념을 자세히 설명하는 여러 장이 포함되어 있습니다.

각 장은 왼쪽 메뉴에서 찾을 수 있습니다.

개념들은 선형적인 방식으로 가르쳐지며(따라서 다른 지시가 없는 한 위에서 아래로 시작하는 것이 좋습니다) 각 장에서 배경 이론과 실제적인 측면을 설명한다.

개념을 더 쉽게 따르고 추가된 구조를 제공하기 위해 이 책에는 상자, 코드 블록, 색상 힌트 및 기능 참조가 포함되어 있습니다.

박스

코드

아래와 같이 구문이 강조된 코드와 함께 어두운 회색 상자에 있는 수많은 작은 코드 조각을 웹 사이트에서 찾을 수 있습니다;

이것들은 코드 조각만 제공하기 때문에, 필요하다면 주어진 주제에 필요한 전체 소스 코드에 대한 링크를 제공할 것입니다.

색상 힌트

일부 단어는 다른 색으로 표시되어 이 단어들이 특별한 의미를 더 명확하게 표현합니다.

• 정의 : 녹색 단어는 정의, 즉 더 자주 들을 수 있는 것의 중요한 측면/이름을 지정합니다.
• 프로그램 구조 : 빨간색 단어는 함수 이름 또는 클래스 이름을 지정합니다.
• 변수 :  파란색 단어는 모든 OpenGL 상수를 포함하는 변수를 지정합니다.

OpenGL 함수 참조

특히 LearnOpenGl의 기능은 콘텐츠에 나타나는 모든 곳에서 OpenGL의 기능을 검토할 수 있는 기능입니다.

웹사이트에 문서화된 콘텐츠에서 기능을 발견될 때마다, 그 기능은 약간 눈에 띄는 밑줄과 함께 나타날 것입니다.

마우스를 기능 위에 올려놓으면 잠시 후 팝업 창에 기능이 실제로 수행하는 작업에 대한 멋진 개요를 포함하여 이 기능에 대한 관련 정보가 표시됩니다. 마우스를 glEnable 위에 올려 놓으면 동작을 볼 수 있습니다.

시작 섹션으로 이동하여 OpenGL 여정을 시작하십시오!

Release v3.1

2022년 11월 둘째주

추가

*이모지*

- 사용자가 세션 내 메뉴 또는 VR 손목 컨트롤을 사용하여 이모티콘을 선택하여 반응을 표시할 수 있는 기능이 추가되었음

*로컬라이제이션*

- 스페인 언어를 지원함

*ENGAGE LINK*

- 중앙광장 헬프데스크에 호출벨을 추가해 공간에 지원요원이 없어도 이용자가 도움을 요청할 수 있도록 함

개선사항

*아바타*

- 사용자가 선택한 아바타가 완전히 다운로드 될때까지 자리 표시자 아바타를 구현함

*로딩 씬*

- 사용자가 위치를 전환할 때 재생되는 로딩 애니메이션을 교체하여 사용자 환경을 더욱 편안하게 만듬

*이메일*

- 사용자의 전자 메일 주소 확인 요청 및 이벤트 등록 확인과 같은 알림 전자 메일에 포함된 링크 및 정보가 업데이트 됨

*움직임*

- VR 기기 사용자가 이러한 이동 방법을 사용하려고 할 경우 팝업을 통해 자유로운 이동을 가능하게 하는 옵션을 제공함

*보안과 성능*

- 플랫폼의 안정성에 도움이 되는 중요한 업데이트 및 개선사항을 적용함

수정사항

*아바타*

- 전체 동작 추적을 사용할 때 어깨 위치를 수정함

- 기본 아바타와 전신 아바타를 전환할 때 아바타의 머리 회전이 심하게 꺽이는 문제를 해결함

- 빨간색 텍스트로 표시되는 부재중 알림을 수정함

- 사용자의 내 얼굴 컬렉션과 할당된 이름이 일치하지 않을 수 있는 문제를 해결함

- 사용자가 여러 구성을 순환할 때 아바타 편집기에 내 얼굴이 잘못 표시될 수 있는 문제를 해결함

*알림*

- 사용자가 호출, 착석 또는 녹음되기 전에 발생하는 오디오 카운트다운을 복원함

*영구 세션*

- 최대 영구 세션 할당량에 도달했을 때 사용자가 그룹의 영구 세션 중 하나에 가입할 수  없도록 하는 문제를 해결함

- 사용자가 영구 세션에 가입할 때까지 영구 세션을 편집할 수 없도록 하는 문제를 해결함

*내용 편집기*

- 내용 편집기를 나갔다가 다시 입력하면 파일 이름 및 장면 제목과 같은 메타데이터가 재설정됨

- 콘텐츠 편집기에 있는 동안 지원되는 위치에서 고해상도 비디오를 재생할 수 있는 기능이 추가됨

*ENGAGE LINK*

- 사용자가 링크 공간에 가입하려고 할 때 응용 프로그램 버전 오류가 발생하는 문제를 해결함

*장치 정보*

- 사용자 페이지에서 탐지된 Steam PC VR 장치 목록이 정확한지 확인하기 위한 수정 사항 구현

*미디어 공유*

- 미디어를 공유하는 동안 포털을 통해 이동하면 사용자가 대상에서 미디어를 공유할 수 없는 문제를 해결함

- 3D 크로마키 비디오의 모양을 고침

- 웹 링크를 통해 로드되는 파워포인트 프레젠테이션 표시와 같은 문제를 해결하는 독립형 VR 장치의 모바일 웹 브라우저 버전을 복원함

*LITE 유저*

- 모든 사용자가 세션에 가입할 때 일시적으로 LITE 사용자로 식별되는 문제를 해결함

*모든 VR 장치*

- 세션을 종료하거나 포털에 들어갈 때 검은색으로 완전히 사라지도록 전환을 수정함

*PC VR 장치*

- 왼쪽과 오른쪽 눈의 보기가 약간 다르게 만드는 스팀 VR 버그에 대한 해결책을 구현함

*VIVE 장치*

- 세션에서 비디오를 재생할 때 VIVE Focus Plus 헤드셋이 충돌하는 문제를 해결함

*로컬라이제이션*

- 세션 내 메뉴의 사용자 페이지에서 정렬 옵션에 대한 도구 설명의 모양을 수정함

- UI에 누락된 현지화 문자열이 추가됨

- 지역화된 긴 이름을 가진 공간에 대해 ENGAGE LINK 맵의 레이블 배치를 수정함

*이벤트*

- 이전 요청이 허용된 후 사용자가 이벤트에 대한 액세스를 요청할 수 있는 옵션이 제거됨

Release v3.1.1

2022년 11월 둘째주

수정사항

*이모지*

- 확장 가능한 이벤트에서 이모지를 사용할 수 있도록 수정 사항을 적용했음

*미디어 공유*

- URL 리디렉션에서 로드된 비디오가 다시 시작하기 몇 초 전에 반복적으로 재생될 수 있는 문제 해결

*음성 커뮤니케이션*

- 확장 가능한 이벤트에 잘못된 VoIP 서비스를 선택하여 사용자를 음소거 상태로 잠그지 못하게 할 수 있는 문제를 해결함

*로컬라이제이션*

- UI에 누락된 현지화 문자열이 추가됨

원문 :https://learn.microsoft.com/en-us/windows/mixed-reality/altspace-vr/world-building/world-building-getting-started

1. 월드 생성 시작하기

*나만의 새로운 AltspaceVR 월드 만들기*

이 가이드는 첫 번째 Altspace VR World를 만들고 공유하는데 도움이 됩니다!

아래 지침은 브라우저에서 월드를 만드는 단계를 안내합니다.

헤드셋의 Altspace VR 앱을 사용하여 월드를 만들 수도 있습니다.

1) AltspaceVR 웹사이트에서 월드 생성하기

1. 무료 Altspace VR 계정을 아직 등록하지 않은 경우 가입합니다.

2. Altspace VR을 처음 사용하는 경우 두 가지 튜토리얼을 완료하는 것이 좋습니다.

연결하려면 Altspace VR 앱을 열고 메인 화면에서 Tutorials를 클릭합니다.

3. Altspace VR 앱에서 메인 페이지로 가서 Main Menu를 클릭합니다.

4. 그리고 하단의 Settings 버튼을 누릅니다.

5. General 탭의 Enable Worlds Beta 버튼을 활성화합니다.

버튼을 누른다면 하단의 메뉴에서 WORLDS라는 아이콘 바가 나타납니다 그리고 My Worlds 옵션이 AltspaceVR 웹사이트에서 활성화됩니다.

6.  https://altvr.com/ 로 들어가서 로그인합니다.

7. 상단의 메뉴 바에서 More 버튼을 클릭한 후에 Worlds 를 클릭합니다.

8. Worlds 메뉴 바에서 My Worlds를 선택합니다.

9. Create Universe 버튼을 누릅니다.

10. Create Universe 화면에서 당신의 세계의 이름과 설명을 적습니다.

11. 월드에 소유자만 참여할수 있도록 하려면 Private 옵션을 선택합니다.

12. Choose File 버튼을 통해 Image를 등록하면 웹사이트와 VR에서 세계를 홍보하는데 쓰여집니다.

13. Profile Image에 이미지를 등록하면 웹사이트와 VR에서 세계를 홍보하는데 쓰입니다. 하지만 Universe Page에 Image가 나타납니다.

14. 원하는 경우 나머지 텍스트 상자를 채웁니다 : 유튜브 비디오 아이디, 트위터 Handle, 태그

15. Create Universe 버튼을 누릅니다.

세계가 만들어지고 나서 새로운 페이지가 생성되고 왼쪽 아래에 다음 옵션을 사용할 수 있습니다.

(세계를 보려면 아래로 스크롤해야 함)

16. Create World 버튼을 누릅니다.

17. World의 이름과 설명을 적습니다.

18. Privacy Setting에 따라 Private 나 Unlisted를 선택합니다.

19. 원한다면 나머지 텍스트 상자와 고급 옵션을 채웁니다.

기본 상황별 역할

고급 포맷

20. 화면 오른쪽에서 템플릿을 선택합니다. 이를 통해 처음부터 만들어진 가상화 환경을 제공합니다.

나중에 변경할 수 있습니다.

Altspace VR에서 제공하는 템플릿 또는 내가 작성한 템플릿을 선택할 수 있습니다.

나의 템플릿(OWNER 라벨이 붙어있는)를 보려면 화면 아래로 스크롤합니다.

21. Create World 버튼을 누릅니다.

월드가 생성되면 아래의 목록들을 할 수 있습니다.

- ENTER NOW 버튼을 클릭하여 세계로 들어갈 수 있음

- 창 왼쪽 아래에 있는 월드 도구를 사용하여 다양한 작업을 수행할 수 있음

- POST MESSAGE 버튼을 클릭하여 메시지를 게시할 수 있음

- 모든 custom 월드를 보려면 Universe 페이지로 돌아가야하는데 그 때 Universe 이름을 클릭하면 가능함

2) AltspaceVR 앱에서 월드 보기

1. Altspace VR 앱에서 WORLDS 단추를 클릭한 다음 위쪽 메뉴 모음에서 MY WORLDS를 클릭합니다.

그러면 FEATED WORLDS 창이 표시되고 Altspace VR 웹사이트에서 만든 월드가 표시됩니다.

2. 작성한 월드 위로 커서를 이동하면 ENTER 및 INFO라는 두 개의 버튼이 나타납니다.

INFO 버튼을 클릭하여 세계에 대한 세부 정보를 확인합니다. 완료했으면 Info 화면의 왼쪽 아래에 있는 ENTER 버튼을 클릭합니다.

축하합니다! 당신은 당신의 첫 번째 Altspace VR 월드, 당신만의 멀티플레이어 소셜 VR 경험을 만들고 입력했습니다! 배치하고 조작할 수 있는 개체가 포함된 키트부터 시작하여 World Editor를 사용하는 것이 좋습니다.

3) 월드 공유하기

1. 공유할 사람이 있는 곳으로 이동합니다.

  월드 또는 이벤트로 이동하려면:

  ● Altspace VR 앱의 기본 페이지로 이동하고 버튼 모음에서 검색을 클릭합니다.

  ● 이벤트를 선택합니다.

  ● 왼쪽 상단 모서리의 설명 아래에 있는 Enter 버튼을 클릭합니다.

2. 이벤트를 입력한 후 왼쪽 하단 모서리에 있는 메뉴 버튼을 클릭합니다.

... 단추 표시줄에서 월드를 클릭합니다.

3. 상단 메뉴 바에서 MY WORLDS를 선택합니다.

4. 월드를 찾은 다음 그 위에 커서를 놓고 정보를 선택합니다.

5. 포탈을 생성하기 위해서 Portal 버튼을 클릭합니다.

6. 사용자가 포털을 사용하여 파티에 참여할 때까지 기다립니다.

7. 준비가 되었으면 포털을 다시 선택하여 귀하의 월드로 이동하십시오.

8. 파티를 시작합니다! 여러분의 친구들은 여러분이 세상을 바꿀 때 여러분의 세상의 변화를 볼 것입니다.

여러분의 창의력으로 그들을 현혹시키세요.

2022.10.28

새로운 기능

*보호장치*

- 두 명의 사용자가 가까이 접근하면 서로 보이지 않도록 개인 경계 시스템 구현

*호스트 제어*

- 세션에서 개인 경계를 사용하거나 사용하지 않도록 설정할 수 있는 기능을 호스트에게 제공

- 호스트에 전체 몸체와 함께 나타나는 아바타와 저전력 장치의 기본 몸체와 함께 나타나는 아바타를 설정하는 제어 기능 제공

- 세션에서 LITE 사용자를 음소거하는 옵션이 추가됨

- LITE 계정을 식별하는 세션의 사용자 목록에 레이블을 추가함

*좌석*

- 사용자가 한 좌석에서 다른 좌석으로 순간이동할 수 있는 기능 추가

*계정 관리*

- 사용자가 Engage 응용 프로그램 내에서 계정 삭제 가능

*데스크톱 장치*

- 일반적으로 사용되는 컨트롤을 표시하는 Windows 데스크톱 장치에 오버레이 및 스플래시 화면을 추가함

*이벤트*

- 이벤트에 등록할 때 사용자가 마케팅 커뮤니케이션에 참여할 수 있는 옵션이 추가됨

맞춤형 솔루션은 Engage 팀을 통해서만 제공됨

*미디어*

- 3D 크로마키 비디오 지원이 추가됨

- 공유 화면을 통해 로드된 비디오를 루프하는 옵션 추가

*UI*

- 세션 내 메뉴의 사용자 페이지에 검색 기능이 추가되었으며, 가입 순서, 이름, 아바타 유형, 장치 유형 또는 호스트 상태별로 정렬할 수 있는 기능이 추가됨

*Meta Quest 장치*

- Meta Quest Pro 헤드셋 지원이 추가됨

- Unity XR 플러그인이 업데이트됨

- 지원을 유지하기 위해 Oculus for Business를 통해 관리되는 헤드셋용 응용 프로그램의 별도 버전을 만듬

*Steam*

- 최신 Unity XR 플러그인 버전으로 업그레이드됨

개선사항

*아바타*

- 아바타의 골격 구조를 최적화하여 복잡성을 줄이고 성능을 향상시킴

- 데스크톱과 PC VR 이외의 기기에 나타나는 전신 아바타의 수를 최대 5개로 표준화함

- 기본 아바타에서 흰색 옷의 밝기를 감소 시킴

*콘텐츠 에디터*

- 곡선 편집기에서 키를 선택하고 숫자 입력 및 스피너 컨트롤을 사용하여 시간 및 값 속성을 모두 조정할 수 있는 기능이 추가됨

- 원곡선 편집기에서 키를 선택하고 수직 또는 수평 축으로만 이동을 제한하는 기능이 추가됨

- 도프 시트 및 원곡선 편집기에 표시된 시간을 주 타임라인과 일치시킴

- 원곡선 편집기에서 트랙을 숨기는 옵션이 추가됨

- 내용 편집기를 작성 및 편집 페이지의 기본 옵션으로 설정함

- 페이드 인 및 페이드 아웃 기간에 대한 사용자 정의 시간 길이를 컬러 IFX로 설정하는 기능이 추가됨

- 현재 플레이 헤드 위치를 변경하지 않도록 '프레임 선택' 기능의 동작이 업데이트됨

- 개체 컨테이너의 시작 위치에 추가된 자동 생성 키프레임을 제거함

- 녹화에 캡처된 애니메이션과 키를 사용하여 녹화에 적용된 애니메이션에 대해 별도의 루프 컨트롤을 구현함

*이벤트*

- 콘서트에 대한 새로운 이벤트 유형을 추가함(맞춤형 솔루션은 Engage 팀을 통해서만 제공됨)

- 사용자가 콘서트 이벤트에 있을 때 세션 내 메뉴에서 초대 단추를 제거함

- 이벤트에 대한 등록 마감 날짜를 설정하는 기능이 추가됨

- 이벤트 목록 페이지에 콘서트 이벤트에 대한 가용성 표시기를 추가하여 매진 및 제한된 가용성을 식별함

*위치*

- 사용자가 새 세션으로 이동하기 전에 위치를 다운로드 할 수 있는 기능이 추가됨

*오디오*

- 포털을 통과할 때 사용자의 개인 음소거 상태를 지속되도록 설정함

- 호스트가 음소거 잠금 제한을 제거할 때 사용자에게 원하는 경우 음소거를 해제할 수 있음을 알리는 알림이 추가됨

*세션*

- 그룹이 공용 세션을 볼 수 없는 경우 사용자가 공용 세션을 만들 수 없음

- 사용자가 세션에 참여하거나 포털을 통해 이동할 때 애니메이션 로딩 화면을 구현함

- 사용자가 항상 참여할 수 있도록 영구 세션에 참여하는 시스템을 개선

*미디어*

- 컨트롤이 호버에 나타나도록 세션 내 메뉴에서 비디오 크기를 최대화함

- 비디오가 올바른 가로 세로 비율로 표시되고 16:9 가로 세율 비율 공유 화면을 채우도록 늘어나지 않도록 공유 미디어의 디스플레이가 개선됨

*메뉴 스크린*

- 메뉴 화면을 재설계하고 주변 환경을 변경함

*보안과 성능*

- 플랫폼의 안정성에 도움이 되는 중요한 업데이트 및 개선 사항을 적용함

*UI*

- 항상된 세션 내 알림 시스템을 구현함

- 사용자 페이지의 권한 아이콘에 도구 설명이 추가됨

- 나열된 사용자의 개별 페이지를 스크롤 가능한 단일 페이지로 바꿈

- [사용자] 페이지에서 [초대] 단추의 위치를 변경함

- 새 기능에 대한 추가 정보가 포함된 응용 프로그램 내 지침 패널이 추라됨

- 데스크톱 및 VR 기기에서 애플리케이션 내 커서를 더 작게 만들어 보다 정확한 선택이 가능하도록 함

- 콘텐츠 재생 컨트롤을 세션 메뉴의 콘텐츠 페이지로 이동함

수정사항

*아바타*

- 기본 아바타에 머리가 돌출되지 않도록 남성 헤드 스카프(ghutrah and agal)를 조정함

- 특정 의상으로 여성 아바타의 어깨에 눈에 보이는 솔기를 발생시킨 문제를 수정하고 마이 페이스(My Face)를 선택함

- 아바타가 특정 제스처를 수행할 때 아바타의 팔이 일부 옷을 통해 나타날 수 있는 문제를 수정함

- 아바타의 다리가 겹치지 않도록 드레스와 스커트의 여성 착석 자세를 고침

*콘텐츠 에디터*

- 사용자가 효과 옵션 매개 변수를 편집할 때 스페이스바를 눌러 3재생을 시작할수 없도록 막음

- Gizmo로 스케일링된 객체가 새 스케일을 저장하지 않는 문제를 수정함

- 개체에 대한 사용자 지정 이름이 시간 표시 막대에 표시되지 않도록 수정함

- 3D 모델의 루트에 포함된 애니메이션 때문에 Content Editor에서 3D 모델에 적용된 애니메이션이 세션에서 재생되지 않는 문제를 해결함

- 도프 시트에 있는 동안 애니메이션을 재생하기 시작한 다음 타임라인으로 전환하여 애니메이션을 계속 재생하지만 타임라인 시간 카운터가 정적인 상태로 유지되는 문제를 해결함

*미디어*

- 360 비디오 룸에서 볼 때 문제가 있었던 스테레오 비디오의 선택 항목에 대한 왼쪽-오른쪽 눈 할당 수정

- 미디어 재생이 실패하고 후속 미디어가 로드되지 않을 수 있는 문제를 해결함

- 비디오 검색 결과 제목에 ampersands 표시를 수정함

- 사용자가 데스크톱을 공유한 다음 모니터를 전환할 때 연결된 웹캠이 활성화되는 문제를 해결함

- IFX 화면이 반투명해지고 뒤에 물체가 나타날 수 있는 문제를 해결함

*호스트 제어*

- 사용자의 호스트 상태가 변경될 때 사용자 페이지를 즉시 업데이트하는 수정 프로그램을 적용함

*IFX*

- 사용자가 앉아 있는 IFX 의자의 Gizmo에 액세스할 수 없도록 제한함

*로컬라이제이션*

- 누락된 현지화 텍스트를 Gizmo에 추가함

- 일부 언어에서 공유 화면 페이지에 나타나는 중복 텍스트를 수정함

*PLUS 구독*

- 영국이 부가가치세 목적으로 EU에 분류되는 것을 제거함

*포탈*

- 동일한 포털을 통해 동일한 대상으로 이동하는 사용자가 중복 대상 세션에 나타날 수 있는 문제를 해결함

*레코딩*

- 기록이 너무 길어질 경우 저장하지 못할 수 있는 문제를 해결함

- 기록 페이지에서 공유 화면으로 잘못 분류된 활성 탭의 이름을 수정함

*Vive 장치*

- VIVE Focus 3 장치에 새로 설치한 후 사용자가 UI와 상호 작용할 수 없는 문제를 해결함

- VIVE Flow 3 DoF 컨트롤러 다이어그램의 레이블을 수정함

---------------------------------------------------------------------------------------------------------------------------

생각보다 많은 기능이 추가되었고 개선된 것 같다.

조금 더 다양한 메타버스 플랫폼들을 찾아봐야하겠지만 업데이를 통해 계속 개선해준다면 괜찮은 메타버스 플랫폼일지도

클래스와 다형성에 대해서 어떻게 생각하는가 설명해달라

알고 있는 디자인패턴에 대해 말해봐라

1) 싱글톤

싱글톤과 전역변수의 차이점은 무엇인가?

해시맵(hash_map)이 무엇인가?

- 해시맵은 저장은 느리지만 다량의 데이터를 검색하는데 뛰어난 성능을 가진 맵 인터페이스계열의 대표적인 클래스

- 키(key)와 값(value)의 쌍으로 이루어짐

- 해시 테이블이라는 자료구조를 사용함으로써 검색 속도가 map, set에 비해 빠름

  ● map,set을 사용하는 경우 : 정렬된 상태로 자료 저장을 하고 싶은 경우
  ● hash_map, hash_set을 사용하는 경우 : 정렬이 필요 없으며 빠른 검색을 원할 때

- 빈번한 자료 삽입, 삭제의 경우와 저장한 자료가 적을 때는 메모리 낭비와 검색 시 오버헤드가 생기기 때문에 사용하지 않는 것이 좋음

정적라이브러리와 동적라이브러리의 차이점은?

- 정적라이브러리는 실행할 때 라이브러리의 내용을 모두 메모리에 로드하는 반면 동적 라이브러리는 메모리에 이미 존재하는 경우 로드되는 시간과 공간을 아낄 수 있음

- 정적 라이브러리는 매번 라이브러리의 주소에 접근해야 하기 때문에 오버헤드가 존재해 수행 시간은 정적 라이브러리보다 느림

값 전달 방식에 어떠한 차이점이 있는가

value로 전달

- 얕은 복사가 이루어짐

reference로 전달

- 깊은 복사가 이루어짐

스마트 포인터의 종류를 말해보라

스마트 포인터를 사용하는 이유와 경우에 대해 말해보라

형변환을 쓰는 이유에 대해 말해보라