//Frustum.h
#pragma once
#include "Components/DXCamera.h"
class Frustum
{
private:
DXCamera* camera; //view,Projection 행렬을 가져오기 위한 변수
float planeEpsilon; // 평면테스트에서 사용되는 부동 소수점 오차범위를 나타냄
XMVECTOR frustumPlane[6]; //Plane : 평면 -> 절두체 평면
public:
bool Initialize(DXCamera* camera, float planeEpsilon = FLT_EPSILON);
void ConstructFrustum();
//IsInFrustumBounds~ 함수 설명
//물체의 기준으로 히트박스(Bounds뒤에 들어가는 도형,도형은 자유) 만들어서 그 안에있으면 있따고 처리 체크
bool IsInFrustum(XMFLOAT3 v); //Frustum 안에 물체 확인 bool 변수
bool IsInFrustum(XMVECTOR v); //Frustum 안에 물체 확인 bool 변수
bool IsInFrustumExceptUpDown(XMFLOAT3 v); //Frustum의 윗면과 아랫면은 무조건 있는걸로 취급하고 좌우앞뒤만 체크하는 변수
bool IsInFrustumBoundsSphere(XMFLOAT3 v,float radius); //Frustum 안에 물체의 기준으로 구 모형 안에 있는지 물체 확인 bool 변수
bool IsInFrustumBoundsSphere(XMVECTOR v, float radius); //Frustum 안에 물체의 기준으로 구 모형 안에 있는지 물체 확인 bool 변수
bool IsInFrustumBoundsSphereExceptUpDown(XMFLOAT3 v, float radius); //Frustum안에 물체의 기준으로 구 모혀 위와 아래는무조건 있는걸로 취급하고 좌우앞뒤만 체크하는 변수
bool IsInFrustumBoundsCube(XMFLOAT3 v, float radius); //Frustum 안에 육면체 모양 안에 물체 확인 bool 변수
bool IsInFrustumBoundsCube(XMVECTOR v, float radius); //Frustum 안에 육면체 모양 안에 물체 확인 bool 변수
//Rectangle : AABB/OBB -> 2D게임 만들때거나 3D게임의 UI 만들때 사용
bool IsInFrustumBoundsRectangle(XMFLOAT3 v, XMFLOAT3 r); //Frustum 안에 2D사각형 안에 물체 확인 bool 변수
bool IsInFrustumBoundsRectangle(XMVECTOR v, XMVECTOR r); //Frustum 안에 2D사각형 안에 물체 확인 bool 변수
private:
bool IsInBoundsCube(XMVECTOR p, XMFLOAT3 v, XMFLOAT3 r);
};
//====================================================================
#include "Frustum.h"
bool Frustum::Initialize(DXCamera* camera, float planeEpsilon)
{
if (!camera) return false; // 매개변수 camera 가 존재하지 않으면 false 반환
//Frustum data 초기화
this->camera = camera;
this->planeEpsilon = planeEpsilon;
for (int i = 0; 6 > i; i++) frustumPlane[i] = XMVectorSet(0, 0, 0, 0);
return true;
}
void Frustum::ConstructFrustum()
{
//최종 vertex는 (-1,-1,0) ~ (1,1,1) 사이의 값으로 바뀐다.
//최종Vertex = Vworld * ViewMatrix * ProjectMatirx해서 나온 Frusutm 영역의 8개 vertex data임.
XMFLOAT3 frustumVertices[8] =
{
{-1.0f, -1.0f, 0.0f }, // near left bottom v0
{1.0f, -1.0f, 0.0f }, // near right bottom v1
{1.0f, -1.0f, 1.0f }, // far right bottom v2
{-1.0f, -1.0f, 1.0f }, // far left bottom v3
{-1.0f, 1.0f, 0.0f }, // near left top v4
{1.0f, 1.0f, 0.0f }, // near right top v5
{1.0f, 1.0f, 1.0f }, // far right top v6
{-1.0f, 1.0f, 1.0f }, // far left top v7
};
//view * proj의 역행렬 계산.
XMMATRIX invViewProjectionMatrix = XMMatrixInverse(NULL, camera->GetViewMatrix() * camera->GetProjectionMatrix());
XMVECTOR frustumVectors[8]; //최종vertex * (viewprojectionMatrix)T를 계산한 vertex들의 vector
for (int i = 0; 8 > i; i++)
{
// XMVector3TransformCoord : 주어진 행렬을 사용하여 벡터로 변형하는 함수
//최종vertex * (viewprojectionMatrix)T 계산,
frustumVectors[i] = XMVector3TransformCoord(XMVectorSet(frustumVertices[i].x, frustumVertices[i].y, frustumVertices[i].z, 1.0f),
invViewProjectionMatrix);
}
//계산된 Vworld(월드상의 vertex)들을 3개씩 사용하여 절두체의 평면을 구성
//인덱스 순서에 따라 절두체면(폴리곤)의 윗면이 결정되어 윗면이 법선벡터의 방향이다.(중요)
frustumPlane[0] = XMPlaneFromPoints(frustumVectors[4], frustumVectors[7], frustumVectors[6]); // 상 평면(top)
frustumPlane[1] = XMPlaneFromPoints(frustumVectors[0], frustumVectors[1], frustumVectors[2]); // 하 평면(bottom)
frustumPlane[2] = XMPlaneFromPoints(frustumVectors[0], frustumVectors[4], frustumVectors[5]); // 근 평면(near)
frustumPlane[3] = XMPlaneFromPoints(frustumVectors[2], frustumVectors[6], frustumVectors[7]); // 원 평면(far)
frustumPlane[4] = XMPlaneFromPoints(frustumVectors[0], frustumVectors[3], frustumVectors[7]); // 좌 평면(left)
frustumPlane[5] = XMPlaneFromPoints(frustumVectors[1], frustumVectors[5], frustumVectors[6]); // 우 평면(right)
}
bool Frustum::IsInFrustum(XMFLOAT3 v)
{
return IsInFrustum(XMVectorSet(v.x, v.y, v.z, 1.0f));
}
bool Frustum::IsInFrustum(XMVECTOR v)
{
return IsInFrustumBoundsSphere(v, 0.0f);
}
bool Frustum::IsInFrustumExceptUpDown(XMFLOAT3 v)
{
return IsInFrustumBoundsSphereExceptUpDown(v, 0.0f);
}
bool Frustum::IsInFrustumBoundsSphere(XMFLOAT3 v, float radius)
{
return IsInFrustumBoundsSphere(XMVectorSet(v.x, v.y, v.z, 1.f), radius);
}
//절두체 안에 경계구가 있는지 체크하는 함수( 작동방식 밑에 서술)
bool Frustum::IsInFrustumBoundsSphere(XMVECTOR v, float radius)
{
for (int i = 0; 6 > i; i++) // 왜 6인가? 절두체의 면이 6개임
{
//XMPlaneDotCoord의 함수 반환값은 XMVECTOR인데, XMVECTOR의 모든값을 내적크기로 반환한다.
//VectorGetX,Y,Z 함수 아무거나 사용해도 괜찮다. 전부 내적의 값이기 떄문이다.
if (XMVectorGetX(XMPlaneDotCoord(frustumPlane[i], v)) > (radius + planeEpsilon))
{
// 벡터의 내적(물체와 절두체 면의 수직상의 거리) > 물체의 경계(히트박스)거리 가 참인경우
return false; //frustum 영역 외부에 있음
}
}
return true;//frustum 영역 내부에 있음
}
bool Frustum:: IsInFrustumBoundsSphereExceptUpDown(XMFLOAT3 v, float radius)
{
XMVECTOR vector = XMVectorSet(v.x, v.y, v.z, 1.0f);
for (int i = 2; 6 > i ; i++) // 0,1 인덱스의 vertex는 윗면과 ,아랫면의 vertex이므로 제외
{
//XMPlaneDotCoord (평면(plane) , 벡터(vertex) ) : 평면과 벡터사이의 내적값을 반환.
if (XMVectorGetX(XMPlaneDotCoord(frustumPlane[i], vector)) > (radius + planeEpsilon)) return false;
}
return true;
}
//절두체를 경계박스로 컬링하는 함수
bool Frustum::IsInFrustumBoundsCube(XMFLOAT3 v, float radius)
{
for (int i = 0; 6 > i; i++)
{
if (IsInBoundsCube(frustumPlane[i], v, XMFLOAT3(radius, radius, radius))) continue;
return false;
}
return true;
}
bool Frustum::IsInFrustumBoundsCube(XMVECTOR v, float radius)
{
XMFLOAT3 dest;
XMStoreFloat3(&dest, v);
return IsInFrustumBoundsCube(dest, radius);
}
//절두체를 2D사각형으로 컬링하는 함수(2D게임에서 사용하게됨)
bool Frustum::IsInFrustumBoundsRectangle(XMFLOAT3 v, XMFLOAT3 r)
{
for (int i = 0; 6 > i; i++)
{
//
if (IsInBoundsCube(frustumPlane[i], v, r)) continue;
return false;
}
return true;
}
bool Frustum::IsInFrustumBoundsRectangle(XMVECTOR v, XMVECTOR r)
{
XMFLOAT3 destV, destR;
XMStoreFloat3(&destV, v);
XMStoreFloat3(&destR, r);
return IsInFrustumBoundsRectangle(destV, destR);
}
//경계박스 ,및 경계사각형(2D)의 함수 작동방식
bool Frustum::IsInBoundsCube(XMVECTOR p, XMFLOAT3 v, XMFLOAT3 r)
{
return
(
//절두체 면(p) ,벡터v,r연산
//모든 벡터의 내적이 오차범위 보다 작으면 있면 frustum 안에 존재
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x - r.x, v.y - r.y, v.z - r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x - r.x, v.y - r.y, v.z + r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x - r.x, v.y + r.y, v.z - r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x - r.x, v.y + r.y, v.z + r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x + r.x, v.y - r.y, v.z - r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x + r.x, v.y - r.y, v.z + r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x + r.x, v.y + r.y, v.z - r.z, 1.0f))) <= planeEpsilon) ||
(XMVectorGetX(XMPlaneDotCoord(p, XMVectorSet(v.x + r.x, v.y + r.y, v.z + r.z, 1.0f))) <= planeEpsilon)
);
}
최종 Vertex의 값 범위가 (-1,-1,0) ~ ( 1,1,1) 사이의 값으로 바뀐다 라는 주석이 있는데
이 값은 D3D에서는 절대 고정이며 view 변환시 카메라 시점을 원점으로 바꾸고 투영행렬을 계산하여 이미지화 (3D->2D)화 시키기 때문에 그런것이다.
//최종 vertex는 (-1,-1,0) ~ (1,1,1) 사이의 값으로 바뀐다.
//최종Vertex = Vworld * ViewMatrix * ProjectMatirx해서 나온 Frusutm 영역의 8개 vertex data임.
XMFLOAT3 frustumVertices[8] =
{
{-1.0f, -1.0f, 0.0f }, // near left bottom v0
{1.0f, -1.0f, 0.0f }, // near right bottom v1
{1.0f, -1.0f, 1.0f }, // far right bottom v2
{-1.0f, -1.0f, 1.0f }, // far left bottom v3
{-1.0f, 1.0f, 0.0f }, // near left top v4
{1.0f, 1.0f, 0.0f }, // near right top v5
{1.0f, 1.0f, 1.0f }, // far right top v6
{-1.0f, 1.0f, 1.0f }, // far left top v7
};
절두체 각 면의 법선벡터 방향을 정하는 것은
그래픽스 파이프라인 폴리곤을 그리는 방식에 따라 정해진다.
이 블로그의 그래픽스 파이프라인 - 기본용어 정리 -Vertex를 이용하여 삼각형을 그릴때 필요한 개념 내용을 참고하면 좋다.
// DirectX11Graphics.h
#include "Frustum.h"
class DirectX11Graphics final : public Graphics
{
Private:
// Mesh의 이미지 관련 함수들을 담당하고 있음
std::unique_ptr <PrimitiveModel> primitive;
// 컴포넌트 구조의 Mesh Obj : 컴포턴트 추가 및 Update관련(Mesh의 크기,회전,이동 함수등)
DXGameObject primitiveObj;
Frustum frustum; //절두체컬링을 위한 절두체 객체 추가
};
//========================================================
// DirectX11Graphics.cpp
void DirectX11Graphics::RenderFrame() //그래픽스 객체의 Draw 함수(프레임마다 렌더링함수)
{
//렌더링 할때마다 , 카메라시점 기준(뷰행렬,투영행렬)으로 절두체 영역 생성
frustum.ConstructFrustum();
// GameObject Primitive Mesh Draw
//절두체 컬링 - 경계구 판정을 사용하여 Mesh의 위치vector와 크기Vector를 인자값으로 가져감
//크기vector는 경계구의 반지름으로 사용, 해당 객체가 카메라영역에서 사라지고 경계구까지 영역에서 벗어나게되면 절두체 컬링진행
//(이 자리에 경계 구의 반지름 값을 조정하여 넣을 수있음 )
if (frustum.IsInFrustumBoundsSphere(primitiveObj.GetTransform()->GetPosition(), XMVectorGetX(primitiveObj.GetTransform()->GetScale())/*bounds*/))
{
//절두체 6면, 영역 내에 Mesh(객체)가 존재 함으로 Draw를 한다.
primitiveObj.Draw(cameraObj.GetComponent<DXCamera>()->GetViewProjectionMatrix());
}
}
bool DirectX11Graphics::InitializeScene() // 그래픽스 객체의 Scene(장면) Init
{
//상자 mesh
Primitive = std::make_unique<PrimitiveCube>(); // 상자 모양 mesh
Primitive->Initialize(device.Get(), deviceContext.Get(), constantMatricesBuffer);
Primitive->MakePrimitive("Textures\\box.jpg"); // mesh에 텍스쳐 이미지 추가
PrimitiveObj.AddComponent<DXMeshRenderer>()->SetModel(Primitive.get());
//절두체 객체 Init , 카메라의 뷰행렬,투영행렬이 필요하기 때문 -> 역행렬을 구해야함
frustum.Initialize(cameraObj.GetComponent<DXCamera>());
}
//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() 값을 리턴
first, last , result iter(반복자) 초기화 완료while 반복문의 함수 동작후 확인, // while문이 참이므로 반복분 시작
while 반복문에 들어와서
if (!(*result == *first)) , if조건문이 있는데 result와 first가 같으므로 true에 !를 만나 false를 반환
다시 while 반복문의 조건을 확인해서 계속 roop 시키면 ......
result와 first의 값이 달라지는 경우가 발생
if (!(*result == *first)의 true임으로 if문이 동작한다.
*(++result)=*first; 동작 완료시
*first 가 가르키고 있는 20의 data를 result의 다음 반복자(++result)에 data를 정의하는것이다.
그럼 vector의 [1] index의 data는 10-> 20으로 변경된다. 그리고 이 과정을 while이 false가 나올때까지 반복하게 되면
중복 되지 않은 원소는 전부 앞으로 정렬하게 되고, 중복된 원소들은 뒤로 밀리게 되며 반환되는 return 값은 현재 가르키고있는 result의 다음 iter 값이 반환된다.즉, unique함수의 return값은 쓰게기값(중복값)들이 모여있는 첫번째 인덱스를 iter를 반환하게 된다.
이 점을 이용하여 unique한뒤erase함수로 현재 반환 받은 값에서부터 end() 까지 지워버리면
reverse_iterator(역방향 반복자) : 반복자(iterator)와는 정반대로 동작하는 반복자
++,-- 연산자를 이용하여 iter를 변경하고 그랬는데 반대로 동작하게된다.
std::vector에서 자주 사용해온 begin(), end() 명령어는 반환값으로 iter(반복자)를 반환하는데
rbegin(), rend()는 riter(역방향반복자)를 반환한다.
즉,begin() = rend() , end() = rbegin() 인것이다.
예제코드)
#include <iostream>
#include <vector>
#include <algorithm>
int main(void)
{
std::vector<int> v = { 10,20,30,40,50 };
//벡터의 첫 원소부터 차례대로 출력
for (std::vector<int>::iterator iter = v.begin(); iter != v.end(); iter++)
{
int num = *iter;
cout << num;
}
cout <<endl;
//벡터의 뒷 원소부터 역으로 출력 ( riter가 ++ 로 증가하지만 역으로 감소한다)
for (std::vector<int>::reverse_iterator riter = v.rbegin(); riter != v.rend(); riter++)
{
int num = *riter;
cout << num;
}
}
//출력 결과
1020304050
5040302010
이 역방향 반복자를 이용하여 vector 자료형의 내림차순 정렬을 쉽게 만들 수 있다.
내림차순 정렬을 하는 방법은 많지만 주로 코딩테스트를 풀 때 이 방법들을 사용해 왔다.
(sort(구간의 시작값, 구간의 끝값) , sort 함수는 algorithm 헤더에 포함되어있다,)
1.sort함수에서 조건자에 grearter<자료형>() 을 쓴다. 2.조건자를 재량것 compare 함수를 만들어 쓴다.
3.sort함수로 오름차순 정렬한것을 reverse()로 뒤집어 내림차순 정렬로 만들어 쓴다.
4.sort함수의 인자값을 역방향반복자를 매개변수로 넣는다. (이 코드 만들수 있다.)
예제 코드)
#include <iostream>
#include <vector>
#include <algorithm>
void main()
{
std::vector<int> v = { 1,5,2,8,4,9 };
//오름차순 정렬
sort(v.begin(), v.end());
for (int index : v)
{
std::cout << index << " ";
}
std::cout << std::endl;
//내림차순 정렬
sort(v.rbegin(), v.rend()); // 이부분이 v의 원소들을 내림차순 정렬을 한다.
for (int index : v)
{
std::cout << index << " ";
}
return;
}
//출력 결과
//1 2 4 5 8 9 (오름차순 정렬)
//9 8 5 4 2 1 (내림차순 정렬)
//accumulate 함수의 원문
#include <numeric>
template <class InputIterator, class T>
T accumulate (InputIterator first, InputIterator last, T init);
template <class InputIterator, class T, class BinaryOperation>
T accumulate (InputIterator first, InputIterator last, T init, BinaryOperation binary_op);
