//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);
}
Z-buufer : 화면에 그려진 각 픽셀의 Z(깊이) 값을 저장, 절두체에서 픽셀의 깊이 값을 기록하는데 사용(원근감)
Frusturm의 화면을 렌더링하였을때 : (왼)겹치는 영역을 표시 (오) Z-buffer를 적용하여 원근감을 준 화면
각각 다른 Z값(깊이)를 가지고 있는 물체들이 존재 할때 카메라시점으로 보면 A,B의 겹치는 영역이 존재한다. Frusturn(절두체)에서 기록한 Z값을 이용하여 A,B의 겹치는 영역중 가까운 영역부터 그려서 원근감을 부여한다.
Stencil Buffer : 특정 영역이 렌더링 되는것을 막기위해 사용되는 버퍼
FPS 게임중 조준 하는 경우 (왼)적용되기전 (오)Stencil버퍼를 적용 후
위에 사진처럼 렌더링 하기전 Stencil buffer의 데이터를 이용하여 렌더링에서 제외하는것이다. 예시로는 저격총의 에임, 거울에 비춘 물체 시점(거울 안에서만 비춰야되고 거울 밖은 비추면 안되는상황) 스파이/잡임 게임에서 플레이어의 시점으로만 조명이 비추고 나머지는 어둡게하는 상황을 표현할때도 사용됨
이 두 버퍼는 렌더링 되기전에 사용되는 버퍼이며 이 두 버퍼는 개발시에 보통 한번에 만들어서 한번에 작업처리를 한다.
렌더링의 단일 프레임에서 시스템이 화면에 한 픽셀을 여러 번 그리는 것 즉, 겹쳐서 그려진다는 뜻 처리비용이 높아지는 이유 중 하나 (문제점)
이미지 출처 : https://www.racketboy.com/retro/about-video-games-rasterization-and-z-buffer
이미지는 Z-Buffer를 설명하는 이미지이긴 하지만, 오버드로우를 표현하기에는 적절한 이미지여서 포함했다. 현재 이미지를 보면 한 픽셀에 S2 -> S1->S3 순서로 전부 한번씩 그려진후에 최종적으로 S3가 그려진다. 이 부분들은 S3만 그리게 되면 한번만 그리면 되는데 이런식으로 그리게 되면 총 3번의 작업이 되며 처리비용이 높아진다.
*오버드로우를 대처 및 수정하는 방법
1.레이아웃에서 불필요한 배경삭제
의미없는 배경들을 최대한 삭제로 오버드로우를 줄일수 있다.
2.뷰 계층 구조의 평면화
레이아웃들이 겹치면 안보이는데 그려야되는 경우가 생길수 있다. 그럼으로 이런 점을 고려하여 그리면 줄일 수 있다.
3.투명도 감소
화면에 투명 픽셀을 렌더링하는 것(알파렌더링)오버드로우의 주요 원인,
기존 픽셀에 먼저 그리고 투명 픽셀을 혼합하여 원하는 시각효과를 뽑아냄으로 오버드로우가 발생한다.
즉, 투명객체의 수를 줄이면 오버드로우를 어느정도 대처 할 수 있다.
ex)회색 텍스트를 출력하려 할때 , 검정색 텍스트 + 투명 픽셀(투명도 조절) 이게 아닌 회색으로 텍스트를 출력하면 더욱 성능개선이 된다는 뜻
회색 삼각형을 그릴때 녹색픽셀만 그리는게 아닌 빨간색 영역까지 그려지게 된다. (빨간색 영역 = 쿼드 오버드로우)
4개의 픽셀을 기준으로 그리는 이유는 텍스쳐 샘플링 떄문이다. 이 텍스처 샘플링이 부하가 큰 작업이다. 그래서 픽셀 수에 딱 맞는 해상도의 텍스처를 미리 여러개 준비해놓고 픽셀 수에 맞는 준비된 레벨의 텍스쳐만을 사용해서 렌더링을 하게된다. 이 작업을 텍스쳐의 mip level(밉 레벨) 이라고 한다.
즉, mip level은 동일한 그림을 다양한 해상도의 사이즈로 텍스쳐를 준비하는 작업이다.
밉 레벨 계산은 4픽셀 씩 그리면서 ddx,ddy 미분을 해서 정확한 텍스쳐의 밉레벨 계산을 한다.
폴리곤의 크기(화면상의 크기)가 작을수록 쿼드 오버드로우가 심하게 발생된다.
가까이 있는 물체들은 그렇게 심하지 않지만 멀어지면 멀어질수록 쿼드오버드로우가 발생하고있다.
이미지의 빨간색이 쿼드오버드로우가 발생하고 있다는 뜻이며 점점 멀어지게 되면 폴리곤은 한픽셀보다도 작아질수 있다. 픽셀보다 작은데 그 하나의 폴리곤을 나타내기 위해 4개의 픽셀을 사용하는것이다.
쿼드오버드로우를 줄이기 위하여 삼각형의 크기를 한 픽셀보다 더 작아지지 않게 하기 위한 기능이 바로 LOD 기법이다. (오버드로우 때문이 아님)
