메모장

물체의 대부분이 관절체(Articulated Body)로 이루어져있다.

관절체의 큰 특징은 부모-자식 관계를 갖는 구조로 이루어져 있으며 이를 계층구조라 한다.

(상속 개념 X)

자료구조의 트리(Tree)를 이용하여 구현이 가능하다. 

부모 노드(Node) -자식 노드(Node)로 계층구조가 이루어져 있다. 

즉, 계층 구조는 부모-자식 관계를 3D로 구현할떄 사용된다. 

계층구조의 예시 - 사람

왼쪽 그림은 인간형태로 모델링된 메시, 오른쪽 그림은 인간모델의 계층구조를 도식화 한것

트리 구조로 보자면 허리(코어)가 최상위 부모(Root Node)가 되고 허리의 자식노드들이 가슴(상반신)과 엉덩이(하반신)이 되고 이것이 점점 아래로 내려가면서 트리 구조를 구현한다.

p.s 
상속이 계층구조를 띄는거지 계층구조가 상속인것은 아니다.
컴퓨터 그래픽스의 계층구조는 tree자료구조인 nood로 연결되어있는 구조(중요) 

계층 구조 구현은 행렬의 계산이므로 vertex들을 월드매트릭스로 옮기는 과정을 똑같이 진행하면 된다.

행렬 곱 계산시 순서(위치)가 매우 중요하므로 , 순서는 반드시 이 순서대로만 해야된다. (중요)

TransformMatrix(변환행렬) = scaleMatrix * rotationMatrix * translationMatrix

정점 변환 (월드) : Vworld = Vlocal * TM(TransformMatrix)

계층구조의 정점 (자식노드의 메쉬 구현) : Vworld =  Vlocal * TMChild * TMParent

Vlocal : Local Space에 배치되어있는 Vertex

(Local/Model Space : 3D 오브젝트 모델을 처음 생성할 때에 모델을 가장 편리한 방법으로 배치 / 편리한 방법 : 자기 자신을 원점으로 잡음)

계층구조의 정점 구현은 LocalSpace의 자신(Child)의 vertex들이 배치되어있고 TM을 곱하여 월드 매트릭스로 변환 하고 부모의 변환행렬을 곱하여 자신(Child) LocalSpace의 기준을 부모의 원점을 기준으로 바꾸어 구현한다.

즉, 계층구조의 정점 구현시 LocalSpace가 자기 자신이 아닌 부모의 원점을 기준으로 구현하게 된다. 

계층구조는 n개이상으로 구현이 되면 , 부모TM들은 내 위에 부모노드 들을 순서에 유의하며  n개를 전부 곱한다.

n개 계층 표현식 : Vworld = Vlocal * TMChild * TMParent(n) * TMParent(n-1) * ... * TMParent(1) 

예를 들어 오른발(foot_r) 메시가 구현(렌더링)되기 위해서는 다음과 같은 과정을 거친다. 

Vworld =

Vx3ds_foot_r(오른발의 Local Vertex)

* TMx3ds_foot_r (오른발 변환행렬)

* TMx3ds_leg_dr(오른 다리 변환행렬)  

* TMx3ds_leg_ur(오른 허벅지 변환 행렬) 

* TMx3ds_hip(엉덩이 변환행렬) 

* TMx3ds_waist(허리 변환행렬)

밑에 부분은 그냥 내가 공부했던 내용중에 있어서 기입했다. 

p.s 부모 노드들을 다 곱해야되는가?

 꼭 그럴필요는 없다. 다 곱하게되면 세밀한 표현 및 정확한 위치를 얻을수 있지만, 구현 및 처리비용에 중점을 두게 된다면 구현시에 LocalVertex를 mesh를 그릴때 연산해주면된다.

즉, TM을 WorldMatrix라고 지칭하고, mesh를 렌더링(draw)하는 구간에 VLocal(Local vertex)를 연산해주면 월드에 구현이 된다. 

//예시) 오른 다리의 부모TM을 다 곱했다고 가정 

//오른 다리 구현
WorldMatrix = ScaleM * RotationM * TranslationM ;//월드 매트릭스 = TM 
//오른 다리 draw
Vworld_3ds_leg_dr  = Vx3ds_leg_dr * WorldMatrix * WorldMatrix_parent; // WorldMatrix_parent : 오른 다리의 부모TM의 곱
▼
//오른 발 구현 
WorldMatrix = ScaleM * RotationM * TranslationM ;//월드 매트릭스 = TM 
//오른 발 draw
Vworld_x3ds_foot_r = Vx3ds_foot_r * WorldMatrix  * WorldMatrix_parent; // WorldMatrix_parent : 오른 발의 부모TM의 곱(오른다리가 포함되어있음)

※ 공부중인 코드 일부분을 긁어온거라 참고용으로만 봐주세요.

<지구 자전>

//DirectX11Graphics.h
class DirectX11Graphics 
{
private:
	...
    
    DXGameObject cameraObj; // 카메라 Obj
    
   	// PrimitiveModel은 mesh data와 vertex shader에서 사용할 행렬 data가 담겨있다.
    // 즉, Textuer를 렌더링하는 data를 담당하는 변수 
	std::unique_ptr <PrimitiveModel> Earth; 
   
    //Component 구조로 설계한 DXGameObject를 사용
    //Transform으로 크기행렬,회전행렬,이동행렬 수정 및 Set할때 사용됨 
    //RenderComponent만 추가하여 Render 할때 사용되는 변수 
	DXGameObject EarthObj; 

    
    ...
}

//DirectX11Graphics.cpp
void DirectX11Graphics::Update() // update 영역에서 지구를 자전시키는 코드를 생성
{
	...
    
    // timer class를 만들어서 델타타임을 활용 하게 만듬
	const float deltaTime = timer->GetMilisecondsElapesed();
	static float earthYaw = 0;
	
    earthYaw += deltaTime * 0.1f;
	EarthObj.GetTransform()->SetLocalRotation({ 0,earthYaw, 0 });  // 지구의 y축 회전
	
    ...
}

bool DirectX11Graphics::InitializeScene()
{
	...
    
    //지구
    Earth = std::make_unique<PrimitiveSphere>(); //mesh를 구 모양으로 초기화 
    Earth->Set_size(3); //지구의 scale 크기 Set
    Earth->Initialize(device.Get(), deviceContext.Get(), constantMatricesBuffer);// Earth Model Init
    Earth->MakePrimitive("Textures\\earth2048.bmp"); // mesh에 텍스쳐 이미지 추가
    EarthObj.AddComponent<DXMeshRenderer>()->SetModel(Earth.get()); //Renderer component를 추가후 Earth Mesh를 저장
    
    ...
}

void DirectX11Graphics::RenderFrame() 
{
	...
    //GameObject Primitive Mesh Draw
    //world space에 배치된 obj를 뷰투영행렬을 연산해 카메라시점으로 변환
    //인자값으로 카메라obj에 있는 뷰투영행렬을 Get
	EarthObj.Draw(cameraObj.GetComponent<DXCamera>()->GetViewProjectionMatrix());
    
    swapChain->Present(NULL, NULL);
}

코드 작성후 빌드를 하면

이제 계층구조를 활용하여 간단한 태양계를 만들어 볼건데, 

이 그림의 의미는 계층구조를 구성시 부모-자식 관계가 꼭 Mesh 들로만 구성을 하지 않아도 된다는것이다.
(중요한 포인트)
왼쪽 처럼 구성을 한 경우 화면에 보여지는건 정상적으로 움직일 것이다.

하지만 

태양의 자전을 멈추게하면 지구는 공전을 하지 않게 된다.
과학적으로는 태양의 자전으로 인해 지구가 공전 이런 내용이 맞다 하지만, 

내가 사용하고싶은건 태양은 자전을 하지 않지만 지구는 공전을 하는것이 의도면 왼쪽처럼 구성하면 안된다.

만약 태양과 지구가 직접 node로 설계되어있다면

지구Vworld = 지구Vlocal * 지구TM * 태양TM 이 변환식일것이다.
이러면 태양 TM의 크기,회전,이동 행렬이 전부 지구에 직접적으로 연관을 주게 되어 태양이 자전이 멈추게 되면 
지구도 공전을 하지 않게 된다.

하지만 오른쪽 그림의 지구공전이라는 node를 구성하게 되면
지구Vworld = 지구Vlocal * 지구TM * 지구공전TM * 태양TM 이 변환식일것이다.

지구 공전 TM은 회전만하면 되기 때문에 회전행렬만 update가 되고 위치나 크기는 전부 태양TM을 따르게된다.

이렇게 되면 실질적으로 Render 할경우 태양은 자전(회전행렬)을 하지 않아도도 지구공전TM은 회전행렬을 update 하고 있으며 그 동시에 태양 TM의 위치와 크기를 가지고 있다. 이제 지구TM에 부모TM(지구공전TM * 태양TM )을 곱해주면 지구는 지구TM의 회전행렬은 지구공전의 회전행렬이 연산되고 태양 TM의 위치,크기값이 연산됨으로 의도한 결과값을 낼수 있다.

즉, 지구공전,달 공전은 회전행렬만 Update하는 객체(Obj)이며 위치나 크기는 부모들을 따라간다.

내용이 많이 길어지고 복잡해졌지만 적고싶었던 이유는 <계층구조는 무조건 Mesh로만 구성되어있는것이 아니다>는것을 말하고 싶었고, 원하는 의도를 낼려면 이런식으로도 사용 할 수 있다는 것을 적고싶었다.

<태양계 생성>

//DirectX11Graphics.h
class DirectX11Graphics 
{
private:
	...
    
    DXGameObject cameraObj; // 카메라 Obj
    
    // PrimitiveModel은 mesh data와 vertex shader에서 사용할 행렬 data가 담겨있다.
    // 즉, Textuer를 렌더링하는 data를 담당하는 변수 
	std::unique_ptr <PrimitiveModel> Earth; 

    //Component 구조로 설계한 DXGameObject를 사용
    //Transform으로 크기행렬,회전행렬,이동행렬 수정 및 Set할때 사용됨 
    //RenderComponent만 추가하여 Render 할때 사용되는 변수 
	DXGameObject EarthObj; 
  
    //====태양계 생성으로 인한 태양,달 추가 =====//
    std::unique_ptr <PrimitiveModel> Sun; 
    std::unique_ptr <PrimitiveModel> Moon; 
    
    DXGameObject SunObj; 
    DXGameObject MoonObj; 
    DXGameObject Sun_Earth_Obj; //지구 공전 obj
    DXGameObject Earth_Moon_Obj; //달 공전 obj
    
    ...
}

//DirectX11Graphics.cpp
void DirectX11Graphics::Update() // update 영역에서 지구를 자전시키는 코드를 생성
{
	...
    
    // timer class를 만들어서 델타타임을 활용 하게 만듬
	const float deltaTime = timer->GetMilisecondsElapesed();
	static float earthYaw = 0;
	
    earthYaw += deltaTime * 0.1f;
	EarthObj.GetTransform()->SetLocalRotation({ 0,earthYaw, 0 });  // 지구의 y축 회전(자전)
    
	//====태양계 생성으로 인한 태양,달 추가 =====//
	static float SunYaw =0 , MoonYaw =0;
	SunYaw += deltaTime * 0.05f;
	MoonYaw += deltaTime * 0.1f;
    
	SunObj.GetTransform()->SetLocalRotation({ 0, SunYaw, 0 }); // 태양의 y축 회전(자전)
	Sun_Earth_Obj.GetTransform()->SetLocalRotation({ 0, SunYaw, 0 }); // 태양-지구의 y축 회전(지구 공전)
	Earth_Moon_Obj.GetTransform()->SetLocalRotation({ 0, MoonYaw, 0 }); // 달의 y축 회전(자전)
	MoonObj.GetTransform()->SetLocalRotation({ 0, MoonYaw, 0 }); // 지구-달 의 y축 회전(달 공전)
    
    ...
}

//Scenc(장면) Init 함수 (화면에 보여지는 구성 요소들을 초기화하는 함수)
bool DirectX11Graphics::InitializeScene()
{
	...
    //====태양계 생성으로 인한 태양,달 추가 및 node연결 작업 =====//
    //태양
   	Sun = std::make_unique<PrimitiveSphere>(); //mesh를 구 모양으로 초기화 
    Sun->Set_size(10); //태양의 Scale Set
    Sun->Initialize(device.Get(), deviceContext.Get(), constantMatricesBuffer); //Sun Model Init
    Sun->MakePrimitive("Textures\\sun1024.jpg"); // mesh에 텍스쳐 이미지 추가
    SunObj.AddComponent<DXMeshRenderer>()->SetModel(parentPrimitive.get());//Renderer component를 추가후 Sun Mesh를 저장

    //지구공전(Sun_Earth_Obj)의 부모를 태양(SunObj)로 Set
    Sun_Earth_Obj.GetTransform()->SetParent(SunObj.GetTransform());
   
    //지구
    Earth = std::make_unique<PrimitiveSphere>(); //mesh를 구 모양으로 초기화 
    Earth->Set_size(3); //지구의 scale Set
    Earth->Initialize(device.Get(), deviceContext.Get(), constantMatricesBuffer);// Earth Model Init
    Earth->MakePrimitive("Textures\\earth2048.bmp"); // mesh에 텍스쳐 이미지 추가
    EarthObj.AddComponent<DXMeshRenderer>()->SetModel(Earth.get()); //Renderer component를 추가후 Earth Mesh를 저장
    
     // 지구의 x축 좌표 이동(지구 공전 obj 기준으로 x축이동)
    add_pos = { 25.0f,0,0 };
    EarthObj.GetTransform()->AdjustPosition(add_pos); 
    
    //지구(EarthObj)의 부모를 지구공전(Sun_Earth_Obj)로 Set
    EarthObj.GetTransform()->SetParent(Sun_Earth_node.GetTransform());

     //달 공전(Earth_Moon_Obj)의 부모를 지구(EarthObj)로 Set
    Earth_Moon_Obj.GetTransform()->SetParent(EarthObj.GetTransform());
	
	//달
    Moon = std::make_unique<PrimitiveSphere>(); // 구 모양 mesh
    Moon->Set_size(1);
    Moon->Initialize(device.Get(), deviceContext.Get(), constantMatricesBuffer);
    Moon>MakePrimitive("Textures\\moon1024.bmp"); // mesh에 텍스쳐 이미지 추가
    MoonObj.AddComponent<DXMeshRenderer>()->SetModel(childPrimitive.get());
    
    // 달의 x축 좌표 이동(달 공전 obj 기준으로 x축이동)
    add_pos = { 5.0f,0,0 };
    MoonObj.GetTransform()->AdjustPosition(add_pos);
    
     //달(MoonObj)의 부모를 지구공전(Earth_Moon_Obj)로 Set
    MoonObj.GetTransform()->SetParent(Earth_Moon_Obj.GetTransform());
    
    ...
}

void DirectX11Graphics::RenderFrame() 
{
	...
    //GameObject Primitive Mesh Draw
    //world space에 배치된 obj를 뷰투영행렬을 연산해 카메라시점으로 변환
    //인자값으로 카메라obj에 있는 뷰투영행렬을 Get
	EarthObj.Draw(cameraObj.GetComponent<DXCamera>()->GetViewProjectionMatrix());
    
     //====태양계 생성으로 인한 태양,달의 카메라시점 변환 =====//
   	SunObj.Draw(cameraObj.GetComponent<DXCamera>()->GetViewProjectionMatrix());
    MoonObj.Draw(cameraObj.GetComponent<DXCamera>()->GetViewProjectionMatrix());
    
    swapChain->Present(NULL, NULL);
}

위 링크는 첫번째 결과값을 작동원리를 설명했으니 나는 정렬한 두번째 값(10 10 10 20 20 30)으로 설명을 해보겠다.

//unique함수 원문
template <class ForwardIterator>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last)
  {
  if (first==last) return last;

  ForwardIterator result = first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for version (2)
      *(++result)=*first;
  }
  return ++result;
}//출처 : https://www.cplusplus.com/reference/algorithm/unique/

  if (first==last) return last;

first iter와 last iter가 같은경우는 원소가 1개 이하라는 뜻이므로 end() 값을 리턴

while 반복문에 들어와서 

 if (!(*result == *first)) , if조건문이 있는데  result와 first가 같으므로 true에 !를 만나 false를 반환

다시 while 반복문의 조건을 확인해서 계속 roop 시키면 ......

 if (!(*result == *first)의 true임으로 if문이 동작한다.

*first 가 가르키고 있는 20의 data를 result의 다음 반복자(++result)에 data를 정의하는것이다. 

그럼 vector의 [1] index의 data는 10-> 20으로 변경된다. 그리고 이 과정을 while이 false가 나올때까지 반복하게 되면  

중복 되지 않은 원소는 전부 앞으로 정렬하게 되고, 중복된 원소들은 뒤로 밀리게 되며 반환되는 return 값은 현재 가르키고있는 result의 다음 iter 값이 반환된다. 즉, unique함수의 return값은 쓰게기값(중복값)들이 모여있는 첫번째 인덱스를 iter를 반환하게 된다. 

이 점을 이용하여 unique한뒤 erase함수로 현재 반환 받은 값에서부터 end() 까지 지워버리면 

10 20 30 만 남게 되는것이다. 

이 문제는 규칙에 의한 이진 변환시 roop 돌은 횟수와 roop를 돌면서 지운 0의 갯수를 구하는 문제이다.

<플로우 차트>

1.0 제거하기

1-1.문자열 s안에 있는 0과 1을 내림차순 정렬 하기

1-2. 문자열의 0의 첫번째 index값을 찾음

1-3. index값 반환에 성공한경우 if문 동작해서 0을 제거

2. 0을 제거한 문자열 s의 길이 체크후 이진변환

2-1. 문자열을 2로 계속 나눠서 이진 변환시키기

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

using namespace std;

vector<int> solution(string s) {
    vector<int> answer;
    int roop = 0; //roop를 돈 횟수 
    int zero_del = 0; //roop를 돌면서 지워진 0의 갯수
	
    //s이 "1"이되면 roop 종료 
    while (s != "1")
    {
        int zero_index = 0;

        //1. 0제거하기
        sort(s.rbegin(), s.rend());//내림차수 정렬 ex)111100000
        zero_index = s.find("0");
		
        //0을 찾을경우 if문 동작
        if (zero_index != -1)
        {
            zero_del += s.length() - zero_index; // 현재 roop에서 지운 0의 갯수 카운트
            s.erase(s.begin() + zero_index, s.end());
            //문자열의 0 첫번째 index(s.begin() + zero_index) , 문자열 끝index를 지워주면 1만 남게된다.
        }
       

        //2. 0을 제거한 s의 길이 체크후 이진변환
        int zero_del_str = s.length();
        s = ""; //s문자열 초기화 

        while (zero_del_str != 0)
        {
        //10진수를 2진수로 변환하는 방법
            s += to_string(zero_del_str % 2);
            zero_del_str /= 2;
        }
        reverse(s.begin(), s.end());// s문자열 원소를 뒤집어 원하는값으로 바꾸기 
        roop++; //1회 roop
    }


    return { roop,zero_del};
}

이진수를 vector<bool>값으로 나타냈으며 , 반복문 while에 들어가기전 for_each문을 사용하여 문자열s의 값을 vector<bool> 이진수 로 변경을 하였고 반복문에서 반복작업을 하였다. 

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

vector<int> solution(string s)
{
    int zeros{ 0 }, num_transform{ 0 };
    vector<bool> bin;

    for_each(s.cbegin(), s.cend(), [&bin](const char c) {bin.emplace_back(c == '1'); });  //s를 이진수로 변환

    while (true)
    {
        if (bin == vector<bool>{true})
            break;
        
        int ones = count(bin.cbegin(), bin.cend(), true);    //1갯수를 셈
        zeros += bin.size() - ones;                          //0갯수를 셈
        bin.clear();
        
        while (ones > 0)
        { 
            bin.emplace_back(ones % 2);
            ones /= 2; 
        }//1갯수를 2진수로 바꿈. 순서는 거꾸로지만 계산에는 영향없음
        
        ++num_transform;                                   //이진변환 횟수 기록
    }

    return { num_transform,zeros };
}

현재 index와 다음 index 값을 비교해서 다를경우,

answer에 현재 index값을 저장 후 roop를 진행한다.

index+1 했을때 arr의 size보다 크거나 같을경우 마지막 숫자를 answer에 추가하면서

반복문을 탈출한다.

#include <vector>
#include <iostream>

using namespace std;

vector<int> solution(vector<int> arr) 
{
    vector<int> answer;
	
    //arr의 갯수만큼 roop
    for(int i = 0 ; i< arr.size() ; i++)
    {
    	//배열이 범위를 벗어나지 않게 하기위한 조건문
        if( i+1 >= arr.size())
        {
            answer.push_back(arr[i]);
            break;
        }
        
        //현재 index와 다음 index가 다를경우 값을 저장 
        if(arr[i] != arr[i+1])
        {
            answer.push_back(arr[i]);
        }
    }
    
    return answer;
}

algorithm헤더의 unique함수와 std::vector의 erase 함수 두개를 활용하면 해당 배열의 원소 중 중복값을 없앨수 있다.

unique 함수 : 배열에서 원소를  앞에서부터 채워나가며 채운 함수중에 중복이 있으면 뒤로 보내는 함수이다.

unique함수는 중복되지 않은 값들을 나열 한뒤 남은 중복 원소의 첫번째 iterator 값을 반환, 

unique함수를 사용하기전에 sort 함수를 하여 정렬할 필요가 있다.

(unique함수로부터 반환된 iterator , 배열의 끝  iterator) 범위를 eraser함수하면
함수 고유의 값들만 남아있다. 

하지만 이 문제는 함수의 순서를 바꾸지 말라고 하였기에 sort함수를 사용하지 않고 바로 unique함수를 활요한 것이다.

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

vector<int> solution(vector<int> arr) 
{
	//vector 에서 중복되는 함수들을 한곳에 모아 삭제할때 쓰는 구조다.
    arr.erase(unique(arr.begin(), arr.end()),arr.end());

    vector<int> answer = arr;
    return answer;
}

2개의 벡터가 주어지는데 각 벡터의 원소들을 곱하고서 그 합의 최솟값을 구하는 문제이다.
즉, (첫번째 작은 값 * 첫번째 큰 값) + (두번째 작은 값 * 두번째 큰 값) + .... = 최솟값 이 나온다 

2개의 벡터에 하나는 오름차순으로 정렬 하나는 내림차순으로 정렬한뒤

반복문을 이용하여 작은값 * 큰값을 roop할 수 있게 해주면된다.

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;

int solution(vector<int> A, vector<int> B)
{
    int answer = 0;
    
    sort(A.begin(),A.end());
    sort(B.begin(),B.end());
    reverse(B.begin(),B.end());

    
    //양쪽 벡터에서 가장 작은 숫자 하나와 가장큰숫자를 골라서 곱한다.
    
    for(int i=0; i< A.size(); i++)
    {
        answer += A[i] * B[i];
    }

    return answer;
}

#include <vector>
#include <numeric>
#include <algorithm>
using namespace std;
int solution(vector<int> A, vector<int> B){
    sort(A.begin(),A.end());  sort(B.rbegin(),B.rend());
    return inner_product(A.begin(),A.end(),B.begin(),0);
}

 익숙하지 않은 명령어들이 있어서 정리하려고 가져왔다.

*inner_product();

numeric 헤더에 포함된 명령어이며, 내적을 구할때 사용하는 명령어이다.

inner_product(시작값A,마지막값A,시작값B,초기값) 으로 사용된다. 

예제 코드 및 추가적인 내용은 밑에 링크 확인

https://01149.tistory.com/14

*rbegin(),rend()

std::vector 자료형의 내림차순 정렬이 필요할때 , rbegin, rend 함수를 활용하면 가독성 좋은 코드를 짤 수 있다. 

예제 코드 및 추가적인 내용은 밑에 링크 확인

https://01149.tistory.com/15

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> a, vector<int> b) {
    int answer = 0;
    
    for(int i=0; i < a.size() ; i++)
    {
        answer += a[i] * b[i];
    }
    
    return answer;
}