DirectX11의 공부 목적으로 위 링크의 튜토리얼을 보고 제 생각을 포함하여 정리하였습니다.
들어가며
이 튜토리얼에서는 DirectX 11에서 정점 및 픽셀 셰이더를 작성하는 방법을 소개합니다. 또한 DirectX 11에서 정점 및 인덱스 버퍼를 사용하는 방법을 소개합니다.
이는 3D 그래픽을 렌더링하기 위해 이해하고 활용해야 하는 가장 기본적인 개념입니다.
1. 정점 버퍼(Vertex buffer)
구의 3D모델을 예로 들어보겠습니다.
이러한 거의 모든 모델들은 실제로 수백 개의 삼각형으로 구성됩니다.
삼각형(폴리곤)에는 세 개의 점이 있으며 각 점을 정점이라고 부릅니다. 따라서 위 모델을 렌더링하려면 구를 형성하는 모든 정점을 정점 버퍼라고 하는 배열에 넣어야 합니다. 정점 데이터를 가진 이 정점 버퍼를 GPU로 전송하면 GPU에서 모델을 렌더링할 수 있습니다.
2. 인덱스 버퍼 (Index buffer)
인덱스 버퍼는 정점 버퍼와 관련이 있습니다. 그 목적은 정점 버퍼에 있는 각 정점이 그려질 순서를 기록하는 것입니다. 그러면 GPU는 인덱스 버퍼를 사용하여 정점 버퍼에서 특정 정점을 빠르게 찾아 그려냅니다.
인덱스 버퍼의 개념은 책에서 인덱스를 사용하는 개념과 유사하며, 원하는 정점을 훨씬 빠른 속도로 찾는데 도움이 됩니다.
DirectX 문서에 따르면 인덱스 버퍼를 사용하면 VRAM의 더 빠른 위치에 정점 데이터를 캐싱할 가능성이 높아질 수 있습니다. 따라서 성능상의 이유로 이러한 기능을 사용해야합니다.
3. 셰이더 (Shaders)
셰이더는 GPU에 존재하는, 화면에 출력할 픽셀의 위치와 색상을 계산하는 함수입니다.
4. 정점 셰이더 (Vertex shaders)
정점 셰이더란 정점 버퍼에 들어있는 정점을 3D공간으로 변환하기 위해 작성된 작은 함수입니다. 각 정점에 대한 법선 계산과 같이 수행할 수 있는 다른 계산도 있습니다. 정점 셰이더 프로그램은 처리해야 하는 각 정점에 대해 GPU가 호출합니다. 그러므로 정점 셰이더의 호출횟수는 처리해야하는 정점의 개수와 같다. 예시로 정점이 5000개인 모델에 정점 셰이더는 5000번 실행됩니다.
5. 레스터라이저 (Rasterizer)
정점 셰이더로 정점을 3D공간으로 불러 3개씩 모으면 삼각형이 만들어집니다. 그럼 이 삼각형을 픽셀화 해주는게 래스터라이저가 하는 일입니다.(삼각형에 픽셀이 몇개 들어가고 어디에 위치하는지 계산합니다.)
6. 픽셀 셰이더 (Pixel shaders)
픽셀 셰이더란 래스터라이저로 구해진 픽셀이 화면에 출력할 최종색상을 계산하는 작은 함수입니다. 이 또한 정점 셰이더와 같이 GPU가 호출합니다. 모델에 사진을 입힌다던지, 조명 및 기타 대부분의 효과는 픽셀 셰이더에서 처리됩니다.
Camera클래스는 이전에 이야기한 뷰 행렬을 처리합니다. 이는 게임월드에서의 카메라의 위치를 제어하고 셰이더들이 장면을 그릴 때 어디를 보고 있는지를 계산해야 할 때 카메라의 위치를 셰이더들에게 전달합니다.
Model클래스는 3D모델의 형태와 구조를 제어합니다. 이번 시간에서는 단순성을 위해 3D모델을 삼각형 평면으로 만듭니다.
ColorShader클래스는 HLSL 셰이더를 호출하여 모델을 화면에 렌더링하는 역할을 담당합니다.
먼저 셰이더 함수를 살펴보는 것으로 코드를 시작하겠습니다.
Color.vs
정점 셰이더이며 아직은 단순한 텍스트 파일입니다. 그렇기에 빌드에 참여하지 않습니다. 이번시간에 만드는 셰이더의 목적은 가능한 한 단순하게 유지하면서 색상이 있는 삼각형을 그리는 것입니다.
정점 셰이더는 전역 변수의 정의로 시작합니다. 이 전역 변수는 int, float과 같은 다양한 타입을 사용할 수 있고,셰이더가 그 전역변수를 이용하여 작업을 하며 이 값들은 C++ 코드에서 접근해 수정할 수 있습니다.
일반적으로 전역 변수가 한 개, 그 이상이더라도 모든 전역 변수는 "cbuffer"라는 버퍼 개체 유형에 넣습니다. 이러한 버퍼를 논리적으로 구성하는 것은 셰이더의 효율적인 실행뿐만 아니라 그래픽 카드가 버퍼를 저장하는 방식에도 영향을 미치기에 중요합니다. 이 예제에서는 3개의 행렬을 각 프레임을 동시에 업데이트할 것이므로 동일한 버퍼에 넣었습니다.
시멘틱은 셰이더 함수에 들어오는 데이터가 어떤 데이터와 매핑해야 하는지에 대한 힌트를 주는 동시에 용도를 직관적으로 알수 있게 해줍니다.
정점 셰이더와 픽셀 셰이더의 의미가 다르기 때문에 POSITION은 버텍스 셰이더에 작동하고, SV_POSITION은 픽셀 셰이더에 작동하기 때문에 VertexInputType과 PixelInputType의 데이터 구조가 동일하여도 따로 정의하였습니다.
COLOR는 두 가지 모두에 작동합니다. 동일한 유형을 두 개 이상 원하는 경우 끝에 COLOR0, COLOR1 등과 같은 숫자를 추가해야 합니다.
struct VertexInputType
{
float4 position : POSITION;
float4 color : COLOR;
};
struct PixelInputType
{
float4 position : SV_POSITION;
float4 color : COLOR;
};
정점 셰이더는 정점 버퍼가 GPU로 전송되어 GPU가 정점 데이터를 처리할 때 GPU에서 호출합니다. 즉, 정점 버퍼에 들어 있는 정점만큼 호출한다는 뜻입니다.
정점 셰이더의 수행 로직은 ColorVertexShaader입니다. 정점 셰이더에 들어오는 input 데이터는(매개변수)는 당연히 VertexInputType의 데이터 구조와 같아야 합니다.
들어온 데이터(VertexInputType input)에서 world, view, projection행렬을 곱하여 공간 변환을 실행합니다. 그럼 3D게임 월드에서 우리의 관점(카메라)으로, 우리의 관점이 2D 화면에 정점이 배치됩니다. 들어온 데이터의 w 값을 1.0f로 변경한 이유는 1.0f로 변경하지 않으면 위치에 대한 XYZ 벡터만 읽기 때문입니다.(일반적으로 위치는 3차원좌표지만 공간 변환시에는 4차원 벡터를 사용하기 때문에 1로 설정하는 것, 나중에 더 자세히 기술)
그리고 들어온 데이터의 색상 정보를 그대로 아까 계산한 position과 함께 픽셀 셰이더로 결과를 전송합니다.
PixelInputType ColorVertexShader(VertexInputType input)
{
PixelInputType output;
// Change the position vector to be 4 units for proper matrix calculations.
input.position.w = 1.0f;
// Calculate the position of the vertex against the world, view, and projection matrices.
output.position = mul(input.position, worldMatrix);
output.position = mul(output.position, viewMatrix);
output.position = mul(output.position, projectionMatrix);
// Store the input color for the pixel shader to use.
output.color = input.color;
return output;
}
Color.ps
픽셀 셰이더는 화면에 렌더링될 폴리곤의 각 픽셀의 최종 색상을 계산합니다. 픽셀 셰이더는 정점 셰이더의 출력에서 데이터가 들어옵니다.
이번 시간의 픽셀 셰이더는 들어온 데이터의 색을 바로 반환할것이기 때문에 매우 간단합니다.
정점, 픽셀 셰이더의 파일 이름을 가져와 InitializeShader에 전달하면서 호출한다.
bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
bool result;
wchar_t vsFilename[128];
wchar_t psFilename[128];
int error;
// Set the filename of the vertex shader.
error = wcscpy_s(vsFilename, 128, L"../Engine/color.vs");
// Set the filename of the pixel shader.
error = wcscpy_s(psFilename, 128, L"../Engine/color.ps");
// Initialize the vertex and pixel shaders.
result = InitializeShader(device, hwnd, vsFilename, psFilename);
return true;
}
SetShaderParameters로 셰이더의 cbuffer 값을 수정하고, RenderShader를 통해 셰이더를 통해 준비된 버퍼를 렌더링 합니다.
bool ColorShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
XMMATRIX projectionMatrix)
{
bool result;
// Set the shader parameters that it will use for rendering.
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix);
// Now render the prepared buffers with the shader.
RenderShader(deviceContext, indexCount);
return true;
}
5. InitializeShader
이번 튜토리얼에서 가장 중요한 기능 중 하나인 함수입니다.
이 함수는 셰이더 파일을 불러오고 DirectX와 GPU에서 사용할 수 있도록 만드는 기능입니다. 또한 레이아웃 설정과 정점 버퍼 데이터가 GPU의 그래픽 파이프라인에서 어떻게 보이는지 확인할 수 있습니다.
아직 구조를 잘 몰라서 생겼던 의문, 셰이더 함수며 셰이더의 데이터며 모두 GPU 메모리에 위치해 있다.
그래서 GPU에게 전달하는게 당연한 것!
다시 글로 돌아가서 먼저 셰이더에서 처리할 정점 데이터의 레이아웃(형식과 구성) 설정을 다룹니다.
우리가 만든 셰이더에서 사용하는 정점 데이터는 위치 벡터(float4)와 색상 벡터(float4) 두 가지를 사용하므로 두 가지의 정점 데이터 레이아웃 설정을 생성해야 합니다.
가장 먼저 작성해야하는 중요한 SemanticName은 정점 셰이더에 들어갈 정점 데이터가 정점 셰이더의 입력 구조체의 멤버에 매핑 될 수 있게 하는 힌트가 됩니다.
아까 말했듯이 우리는 두 개의 서로 다른 정점 데이터를 사용하므로 첫 번째 레이아웃에는 POSITION을 사용하고 두 번째 레이아웃에는 COLOR를 사용합니다.
다음 중요한 부분은 Format(형식)입니다. 위치 벡터에는 DXGI_FORMAT_R32G32B32_FLOAT를 사용하고 색상에는 DXGI_FORMAT_R32G32B32A32_FLOAT를 사용합니다.
마지막으로 주의해야 할 사항은 버퍼에서 데이터의 간격을 나타내는 AlignedByteOffset입니다.
이 레이아웃의 경우 처음 12바이트는 위치이고 다음 16바이트는 색상이며 AlignedByteOffset은 각 요소가 시작되는 위치를 보여줍니다.AlignedByteOffset에 직접 값을 넣는 대신 D3D11_APPEND_ALIGNED_ELEMENT를 사용하면 간격이 자동으로 파악됩니다.다른 설정은 이 튜토리얼에서는 필요하지 않으므로 지금은 기본값으로 설정했습니다.
그 후 레이아웃이 몇 개인지 구하여 정점 셰이더의 Input layout을 생성합니다. 또한 Input Layout이 생성되면 더 이상 필요없는 Vertex,Pixel shader buffer를 해제 합니다.
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &m_layout);
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
셰이더를 활용하기 위해 설정해야 하는 마지막은 상수 버퍼(Constant Buffer)를 생성하는 일입니다.
정점 셰이더에서 우리가 전역변수라며 cbuffer의 구조를 정의만 했는데 바로 이 cbuffer가 상수 버퍼의 데이터 유형입니다.
다음 코드에서 CreateBuffer을 이용해 실제로 GPU 메모리에 상수 버퍼를 생성하여 포인터로 가지고 있을 것입니다.
상수 버퍼는 셰이더에서 여러 모델이 공통적으로 사용되는 변수를 런타임에서 동적으로 업데이트하기 위해 사용되며, 상수버퍼의 포인터와 SetShaderParmeters를 사용하여 셰이더의 상수 버퍼 값에 접근할 수 있습니다.
// 정점 셰이더에 있는 상수 버퍼(cbuffer)의 설명을 설정합니다.
// 상수 버퍼의 사용 방식을 지정합니다. 여기서는 매 프레임마다 업데이트되므로 D3D11_USAGE_DYNAMIC을 사용합니다.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
// ByteWidth는 상수 버퍼의 크기를 바이트 단위로 지정합니다. 이 경우에는 MatrixBufferType 구조체의 크기를 사용합니다.
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
// BindFlags는 버퍼가 어떤 유형의 버퍼가 될지 지정합니다. 여기서는 상수 버퍼로 사용하므로 D3D11_BIND_CONSTANT_BUFFER를 사용합니다.
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
// CPUAccessFlags는 Usage와 맟춰 사용해야하기에 여기서 D3D11_CPU_ACCESS_WRITE를 사용합니다.
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
return true;
}
6. ShutdownShader
InitializeShader함수에서 설정된 4개의 인터페이스를 해제 합니다.
void ColorShaderClass::ShutdownShader()
{
// Release the matrix constant buffer.
if (m_matrixBuffer)
{
m_matrixBuffer->Release();
m_matrixBuffer = nullptr;
}
// Release the layout.
if (m_layout)
{
m_layout->Release();
m_layout = nullptr;
}
// Release the pixel shader.
if (m_pixelShader)
{
m_pixelShader->Release();
m_pixelShader = nullptr;
}
// Release the vertex shader.
if (m_vertexShader)
{
m_vertexShader->Release();
m_vertexShader = nullptr;
}
return;
}
7. OuputShaderErrorMessage
셰이더관련 에러인지 알려주는 창을 띄워줍니다.
void ColorShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
{
char* compileErrors;
unsigned long long bufferSize, i;
ofstream fout;
// error message text buffer의 포인터를 가져옵니다.
compileErrors = (char*)(errorMessage->GetBufferPointer());
// 메세지의 길이 구하기
bufferSize = errorMessage->GetBufferSize();
// 에러 메세지를 저장할 텍스트 파일 열기 (없으면 생성)
fout.open("shader-error.txt");
// 파일에 에러 메세지 작성
for (i = 0; i < bufferSize; i++)
{
fout << compileErrors[i];
}
// 텍스트 파일 닫기
fout.close();
// 에러메세지 메모리 해제
errorMessage->Release();
errorMessage = nullptr;
// compile errors를 확인하라는 메세지를 팝업창으로 띄웁니다.
MessageBox(hwnd, L"Error compiling shader. Check shader-error.txt for message.", shaderFilename, MB_OK);
return;
}
8.SetShaderParameters
이 함수는 셰이더의 상수 버퍼를 쉽게 설정할 수 있도록 하기 위해 존재합니다.
이 함수에 사용된 행렬은 ApplicationClass 내부에서 생성된 후 Render함수 호출 중에 정점 셰이더로 보내기 위해 이 함수가 호출 됩니다.
// 셰이더에 사용하기 위해 행렬을 전치합니다. (대각선 \ 을 기준으로 뒤집음)
worldMatrix = XMMatrixTranspose(worldMatrix);
viewMatrix = XMMatrixTranspose(viewMatrix);
projectionMatrix = XMMatrixTranspose(projectionMatrix);
그리고 상수 버퍼의 값을 수정해야 하는데 잠금(Map), 잠금 해제(UnMap)라는 개념이 나옵니다. 지금 우리가 수정하려는 값을 가지고 있는건 CPU쪽(+ RAM)이고, 상수 버퍼는 GPU(VRAM)에 존재합니다. 그래서 값을 수정하면서 데이터의 동기화, 일관성을 가지게 해야하기에 나온 개념이 잠금, 잠금 해제 입니다.
잠금은 CPU가 상수버퍼의 메모리 영역에 접근할 수 있게 하며 GPU가 상수 버퍼 메모리 영역에 접근하지 못하게 하며,
잠금해제는 그 반대가 됩니다.
bool ColorShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
XMMATRIX projectionMatrix)
{
HRESULT result;
D3D11_MAPPED_SUBRESOURCE mappedResource;
MatrixBufferType* dataPtr;
unsigned int bufferNumber;
// 셰이더에 사용하기 위해 행렬을 전치합니다. (대각선 \ 을 기준으로 뒤집음)
worldMatrix = XMMatrixTranspose(worldMatrix);
viewMatrix = XMMatrixTranspose(viewMatrix);
projectionMatrix = XMMatrixTranspose(projectionMatrix);
// 상수 버퍼 포인터를 이용해 상수버퍼를 잠급니다.
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return false;
}
// 상수 버퍼의 데이터에 대한 포인터를 가져옵니다.
dataPtr = (MatrixBufferType*)mappedResource.pData;
▼의문점. 마지막에 상수 버퍼의 데이터에 대한 포인터를 가져오는데 이미 상수 버퍼 포인터가 있지만 굳이 또 가져오는 이유가 뭘까?
일반적으로 개체 포인터만 있어도 개체의 멤버에 접근할 수 있지만cpu와 gpu의 메모리 관리 방식이 다르기에 gpu에 있는 개체 포인터로는 그 데이터에 직접 접근할 수 있는 방법을 제공하지 않기 때문이다.
그래서 Map을 이용하여 상수 버퍼를 잠구고 데이터를 변환할거니까 그 데이터를 수정할 수 있는 포인터를 넘겨주는 것이라 생각한다.
Map으로 잠그고 난 후 상수 버퍼의 데이터 값을 수정하고 잠금 해제 후 VS단계에 등록합니다.
// constant buffer의 데이터에 값을 수정한다.
dataPtr->world = worldMatrix;
dataPtr->view = viewMatrix;
dataPtr->projection = projectionMatrix;
// constant buffer의 잠금 해제
deviceContext->Unmap(m_matrixBuffer, 0);
// Set the position of the constant buffer in the vertex shader.
bufferNumber = 0;
// 셰이더의 업데이트된 상수버퍼를 0번 슬롯에 1개 VS단계에 등록한다.
deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer);
return true;
}
9. RenderShader
이 함수는 Render 함수에서 호출되는 두 번째 함수 입니다. 세 가지 기능을 합니다.
첫 번째 기능은 IA단계에서 Input layout을 등록하는 것 입니다. 이를 통해 GPU는 정점 버퍼의 데이터 형식을 알 수 있습니다.
두 번째 기능은 정점 버퍼를 렌더링하는 데 사용할 정점 셰이더와 픽셀 셰이더를 렌더링 파이프 라인에 등록하는 것입니다.
세 번째 기능은 D3D device context를 이용하여 DX11함수인 DrawIndexed를 호출해 폴리곤을 렌더링 합니다.
우리의 목표는 녹색 삼각형을 렌더링하는 것입니다.
void ColorShaderClass::RenderShader(ID3D11DeviceContext* deviceContext, int indexCount)
{
// Set the vertex input layout.
deviceContext->IASetInputLayout(m_layout);
// Set the vertex and pixel shaders that will be used to render this triangle.
deviceContext->VSSetShader(m_vertexShader, NULL, 0);
deviceContext->PSSetShader(m_pixelShader, NULL, 0);
// Render the triangle.
deviceContext->DrawIndexed(indexCount, 0, 0);
return;
}
ModelClass.h
이 클래스는 3D모델의 기하 구조를 캡슐화하는 역할을 합니다. 이 튜토리얼에서는 단순한 녹색 삼각형에 대한 데이터를 수동으로 설정합니다. 또한 삼각형이 렌더링 될 수 있도록 정점,인덱스 버퍼를 생성합니다.
구조체 VertexType은 정점 데이터의 유형입니다. 이 형식의 정의는 아까 생성했던 Input layout과 같아야 합니다.
#pragma once
#include <d3d11.h>
#include <directxmath.h>
using namespace DirectX;
class ModelClass
{
private:
struct VertexType
{
XMFLOAT3 position;
XMFLOAT4 color;
};
Render 함수는 모델의 기하 구조를 그래픽 카드에 배치하여 color shader로 그릴 수 있도록 준비합니다.
bool ModelClass::Initialize(ID3D11Device* device)
{
bool result;
// Initialize the vertex and index buffers.
result = InitializeBuffers(device);
return true;
}
3. Shoutdown
Shutdown 함수는 정점 및 인덱스 버퍼에 대한 종료 함수를 호출합니다.
void ModelClass::Shutdown()
{
// Shutdown the vertex and index buffers.
ShutdownBuffers();
return;
}
4. Render
이 함수는 ApplicationClass::Render 함수에서 호출됩니다. 이 함수는 RenderBuffers를 호출하여 정점, 인덱스 버퍼를 렌더링 파이프라인에 배치하므로 color shader가 이를 렌더링할 수 있습니다.
void ModelClass::Render(ID3D11DeviceContext* deviceContext)
{
// vertex and index buffers를 렌더링 파이프 라인에 배치합니다.
RenderBuffers(deviceContext);
return;
}
5. GetIndexCount
GetIndexCount는 모델의 인덱스 수를 반환합니다. color shader는 이 모델을 그리려면 이 정보가 필요합니다.
int ModelClass::GetIndexCount()
{
return m_indexCount;
}
6. InitialzieBuffers
이 함수는 정점,인덱스 버퍼 생성을 처리하는 곳입니다. 일반적으로 모델을 읽고 해당 데이터 파일에서 버퍼를 생성합니다.
// Set the number of vertices in the vertex array.
m_vertexCount = 3;
// Set the number of indices in the index array.
m_indexCount = 3;
// Create the vertex array.
vertices = new VertexType[m_vertexCount];
// Create the index array.
indices = new unsigned long[m_indexCount];
이제 정점과 인덱스 배열을 세 점과 각 점의 인덱스로 채웁니다. 시계방향으로 점을 그린다는 점에 유의하시길 바랍니다.
이 시계방향으로 그려진 면은 앞면이고 반대방향으로 그려지면 뒷면으로 인식됩니다. 뒷면일 경우 back face culling으로 인해 그려지지 않습니다. 색상은 녹색으로 설정합니다.
정점, 인덱스 배열이 채워지면 이제 이를 사용하여 정점 버퍼와 인덱스 버퍼를 만들 수 있습니다. 두 버퍼의 생성은 동익한 방식으로 수행됩니다.
먼저 버퍼에 대한 설명과 SubResource 포인터를 가지고 CreateBuffer을 호출하여 버퍼를 생성할 수 있습니다
// Set up the description of the static vertex buffer.
vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
vertexBufferDesc.CPUAccessFlags = 0;
vertexBufferDesc.MiscFlags = 0;
vertexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the vertex data.
vertexData.pSysMem = vertices;
vertexData.SysMemPitch = 0;
vertexData.SysMemSlicePitch = 0;
// Now create the vertex buffer.
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
// Set up the description of the static index buffer.
indexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
indexBufferDesc.CPUAccessFlags = 0;
indexBufferDesc.MiscFlags = 0;
indexBufferDesc.StructureByteStride = 0;
// Give the subresource structure a pointer to the index data.
indexData.pSysMem = indices;
indexData.SysMemPitch = 0;
indexData.SysMemSlicePitch = 0;
// Create the index buffer.
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
정점, 인덱스 버퍼가 생성된 후에는 데이터가 버퍼에 복사되었기 때문에 필요하지 않은 정점, 인덱스 배열을 삭제할 수 있습니다.
// Release the arrays now that the vertex and index buffers have been created and loaded.
delete[] vertices;
vertices = 0;
delete[] indices;
indices = 0;
return true;
}
7. ShoutdownBuffers
InitializeBuffers함수에서 생성된 정점, 인덱스 버퍼를 메모리 해제 합니다.
void ModelClass::ShutdownBuffers()
{
// Release the index buffer.
if (m_indexBuffer)
{
m_indexBuffer->Release();
m_indexBuffer = nullptr;
}
// Release the vertex buffer.
if (m_vertexBuffer)
{
m_vertexBuffer->Release();
m_vertexBuffer = nullptr;
}
return;
}
8. RenderBuffers
이 함수는 Render함수에서 호출됩니다. 이 함수의 목적은 정점, 인덱스 버퍼를 렌더링 파이프 라인의 IA단계에 배치하는 것입니다. GPU에 배치된 정점 버퍼가 있으면 셰이더를 사용하여 해당 버퍼로 정점을 렌더링할 수 있습니다.
또한 이 함수는 삼각형뿐만 아니라 점, 선, 등 같이 그리는 방법을 정의 합니다. 이 튜토리얼에서는 정점 버퍼와 인덱스 버퍼를 IA단계에 배피하고 IASetPrimitiveTopology함수를 이용하여 버퍼를 삼각형으로 그려야 함을 GPU에 알립니다.
void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
{
unsigned int stride;
unsigned int offset;
// Set vertex buffer stride and offset.
stride = sizeof(VertexType);
offset = 0;
// Set the vertex buffer to active in the input assembler so it can be rendered.
deviceContext->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
// Set the index buffer to active in the input assembler so it can be rendered.
deviceContext->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
// Set the type of primitive that should be rendered from this vertex buffer, in this case triangles.
deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
return;
}
CameraClass.h
우리는 HLSL셰이더를 코딩하는 법, ColorShaderClass에서 셰이더를 호출하여 각 버퍼를 렌더링하는 법을 살펴보았습니다. 그러나 우리가 놓치고 있는 한 가지는 그것들을 그리는 관점입니다. 이를 위해 Dx11이 장면을 어디서 어떻게 보고 있는지 알려주는 카메라 클래스가 필요합니다. 카메라 클래스는 카메라의 위치와 현재 회전을 추적합니다. 위치, 회전 정보를 사용하여 렌더링을 위해 셰이더에 전달될 뷰 행렬을 생성합니다.
CameraClass의 헤더는 4개의 함수만 사용하여 매우 간단합니다.
SetPosition, SetRotation 함수는 카메라 개체의 위치와 회전을 설정하는 데 사용됩니다.
Render는 카메라의 위치와 회전을 기반으로 뷰 행렬을 생성하는데 사용됩니다.
GetViewMatrix는 셰이더가 렌더링에 사용할 수 있도록 카메라 개체에서 뷰 행렬을 검색하는데 사용됩니다.
올바른 윗방향, 위치, 회전을 이용하여 XMMatrixLookAtLH 함수로 현재 카메라 회전 및 이동을 나타내는 뷰 행렬을 생성할 수 있습니다.
void CameraClass::Render()
{
XMFLOAT3 up, position, lookAt;
XMVECTOR upVector, positionVector, lookAtVector;
float yaw, pitch, roll;
XMMATRIX rotationMatrix;
// Setup the vector that points upwards.
up.x = 0.0f;
up.y = 1.0f;
up.z = 0.0f;
// Load it into a XMVECTOR structure.
upVector = XMLoadFloat3(&up);
// Setup the position of the camera in the world.
position.x = m_positionX;
position.y = m_positionY;
position.z = m_positionZ;
// Load it into a XMVECTOR structure.
positionVector = XMLoadFloat3(&position);
// Setup where the camera is looking by default.
lookAt.x = 0.0f;
lookAt.y = 0.0f;
lookAt.z = 1.0f;
// Load it into a XMVECTOR structure.
lookAtVector = XMLoadFloat3(&lookAt);
// Set the yaw (Y axis), pitch (X axis), and roll (Z axis) rotations in radians.
pitch = m_rotationX * 0.0174532925f;
yaw = m_rotationY * 0.0174532925f;
roll = m_rotationZ * 0.0174532925f;
// Create the rotation matrix from the yaw, pitch, and roll values.
rotationMatrix = XMMatrixRotationRollPitchYaw(pitch, yaw, roll);
// Transform the lookAt and up vector by the rotation matrix so the view is correctly rotated at the origin.
lookAtVector = XMVector3TransformCoord(lookAtVector, rotationMatrix);
upVector = XMVector3TransformCoord(upVector, rotationMatrix);
// Translate the rotated camera position to the location of the viewer.
lookAtVector = XMVectorAdd(positionVector, lookAtVector);
// Finally create the view matrix from the three updated vectors.
m_viewMatrix = XMMatrixLookAtLH(positionVector, lookAtVector, upVector);
return;
}
5. GetViewMatrix
Render함수로 뷰 행렬을 생성,업데이트 한 후, 이 GetViewMatrix를 사용하여 업데이트 된 뷰 행렬을 제공할 수 있습니다.
ApplicationClass::ApplicationClass()
{
m_Direct3D = nullptr;
//////////////////////////////////////////////////////////////////////
// 추가 부분
m_Camera = nullptr;
m_Model = nullptr;
m_ColorShader = nullptr;
//////////////////////////////////////////////////////////////////////
}
2. Initialize
세 개의 새로운 개체를 생성하고 초기화하는 코드를 추가합니다.
bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
bool result;
m_Direct3D = new D3DClass;
result = m_Direct3D->Initialize( screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
//////////////////////////////////////////////////////////////////////
// 추가 부분
// Create the camera object.
m_Camera = new CameraClass;
// Set the initial position of the camera.
m_Camera->SetPosition(0.0f, 0.0f, -5.0f);
// Create and initialize the model object.
m_Model = new ModelClass;
result = m_Model->Initialize(m_Direct3D->GetDevice());
// Create and initialize the color shader object.
m_ColorShader = new ColorShaderClass;
result = m_ColorShader->Initialize(m_Direct3D->GetDevice(), hwnd);
//////////////////////////////////////////////////////////////////////
return true;
}
3. Shutdown
세 개의 개체를 추가로 메모리 해제 합니다.
void ApplicationClass::Shutdown()
{
//////////////////////////////////////////////////////////////////////
// 추가 부분
// Release the color shader object.
if (m_ColorShader)
{
m_ColorShader->Shutdown();
delete m_ColorShader;
m_ColorShader = nullptr;
}
// Release the model object.
if (m_Model)
{
m_Model->Shutdown();
delete m_Model;
m_Model = nullptr;
}
// Release the camera object.
if (m_Camera)
{
delete m_Camera;
m_Camera = nullptr;
}
//////////////////////////////////////////////////////////////////////
// Direct3D 개체를 해제합니다.
if (m_Direct3D)
{
m_Direct3D->Shutdown();
delete m_Direct3D;
m_Direct3D = nullptr;
}
return;
}
4. Render
여전히 장면을 초기화 하는 것으로 시작 됩니다. 그런 다음 CameraClass 개체를 이용해 뷰 행렬을 생성하여 얻어내고
D3DClass개체에서 월드, 투영 행렬을 얻습니다.
그런 다음 ModelClass::Render함수를 이용해 녹색 삼각형 모델 형상을 렌더링 파이프 라인에 배치합니다.
이제 정점이 준비되었으므로 ColorShader를 이용해 정점을 그립니다. 그럼 녹색 삼각형이 백 버퍼에 그려집니다.
이것으로 한 장면이 완성되고 EndScene을 호출하여 백 버퍼를 화면에 렌더링합니다.
bool ApplicationClass::Render()
{
//////////////////////////////////////////////////////////////////////
//추가 부분
XMMATRIX worldMatrix, viewMatrix, projectionMatrix;
bool result;
// 화면을 검은색으로 초기화
m_Direct3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
// 카메라 위치를 기반으로 뷰 행렬 생성
m_Camera->Render();
// camera 와 d3d objects에서 world, view, projection 행렬을 가져옵니다.
m_Direct3D->GetWorldMatrix(worldMatrix);
m_Camera->GetViewMatrix(viewMatrix);
m_Direct3D->GetProjectionMatrix(projectionMatrix);
// 렌더링 파이프라인에 모델의 정점, 인덱스 버퍼를 배치하여 그릴 준비를 합니다.
m_Model->Render(m_Direct3D->GetDeviceContext());
// ColorShaderClass를 사용하여 모델을 렌더링 합니다.
result = m_ColorShader->Render(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix);
if (!result)
{
return false;
}
//////////////////////////////////////////////////////////////////////
// 렌더링된 장면을 화면에 표시한다.
m_Direct3D->EndScene();
return true;
}
행렬에 대한 첨언
행렬이 이 튜토리얼에서 어떻게 작동하는 설명합니다.
정점 셰이더를 살펴보면 해당 셰이더에 들어오는 정점을 월드, 뷰, 투영 행렬로 곱하는 것을 볼 수 있습니다.
정점에 월드 행렬을 곱하면 해당 정점을 3D 세계에 배치하게 됩니다. 월드 행렬에는 이동, 회전, 크기 등과 같은 항목이 적용될 수 있습니다. 따라서 이를 통해 3D공간에서 해당 정점을 올바르게 배치할 수 있습니다.
다음으로 3D세계에 배치된 정점에 뷰 행렬을 곱하면 정점의 위치를 카메라가 보고 있는 위치를 기준으로 다시 업데이트 합니다.
마지막으로 카메라 위치를 기준으로 업데이트된 정점을 투영행렬에 곱하면 2D화면을 기준으로 위치가 업데이트 됩니다.
요약
이제 정점 버퍼와 인덱스 버퍼가 어떻게 작동하는지 기본적인 내용을 배웠을 것입니다. 또한 HLSL을 사용하여 정점 셰이더와 픽셀 셰이더를 작성하는 기본적인 방법을 배웠을 것입니다. 마지막으로, 이러한 새로운 개념을 우리의 프레임워크에 통합하여 화면에 초록색 삼각형을 렌더링하는 방법을 이해했을 것입니다.
그리고 저는 단일 삼각형을 그리기 위해 코드가 꽤 길다는 것을 인지하고 있습니다. 이 모든 것을 하나의 main() 함수 안에 넣을 수도 있었을 것입니다. 그러나 앞으로의 튜토리얼에서는 코드의 변경을 최소화하면서 더 복잡한 그래픽을 처리할 수 있도록 하기 위해 이렇게 올바른 프레임워크를 사용하여 작성했습니다.
초기화
Camera : 카메라 초기 위치 설정
Model : 정점, 인덱스 버퍼 생성 후, 각 버퍼에 데이터 하드코딩
ColorShader : GPU에셰이더생성, 셰이더가 사용할 (shader) Input Layout 생성, 상수 버퍼 생성
업데이트(Render)
Camera : 뷰 행렬 생성
Model : 정점, 인덱스 버퍼를 IA단계에 배치
ColorShader : 상수 버퍼 값(3개의 행렬) 업데이트 후 VS단계에 배치, 셰이더 각 단계에 배치, DrawIndexed 호출(그리기 명령)
연습
1. 삼각형의 색상을 빨간색으로 변경합니다.
정점 데이터의 색상코드를 변경
2. 삼각형을 정사각형으로 바꿔보세요.
정점, 인덱스 버퍼에 들어가는 데이터 수정
3. 카메라를 10만큼 뒤로 이동해보세요.
카메라 초기 위치설정의 깊이(z) 값 조정
4. 색상의 밝기를 절반으로 줄이도록 픽셀 셰이더를 변경해보세요.
픽셀셰이더의 최종 값에 0.5를 곱한다.(나는 더 명확한 차이를 위해 0.2를 곱함)
용어 정리
시멘틱 : 셰이더 함수에 들어온 Input data 구조의 멤버 데이터와 매핑해주는 일종의 태그
셰이더 : 화면에 출력할 픽셀의 위치와 색상을 계산하는 함수
Input layout : 셰이더 함수의 Input data(매개변수)에 들어가는 구조이다. 내 생각으로는 (Shader) Input layout이라고도 생각한다.
상수 버퍼 : 셰이더함수에서 여러 모델이 공통적으로 사용하는 데이터
+ CreateBuffer로 버퍼를 생성하면 GPU에 생성되고 그 인터페이스를 CPU쪽에서 포인터로 관리한다고 하는데 나중에 확인 해 볼 것.
+ 그래서 IASet(Vertex,Index)Buffer는 GPU에 생성된 버퍼를 렌더링 파이프에 배치하는것이라고 한다는데 확인 해 볼 것.
그래픽 카드 이름과 VRAM양을 반환한다, 나중에 디버깅시 도움이 될 수도 있다. (코드 생략)
8. SetBackBufferRenderTarget & ResetViewport
우리가 했던 설정들을 함수화 했는데 나중의 튜토리얼에 다시 사용하기에 미리 함수화 했다.
void D3DClass::SetBackBufferRenderTarget()
{
// Bind the render target view and depth stencil buffer to the output render pipeline.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
return;
}
void D3DClass::ResetViewport()
{
// Set the viewport.
m_deviceContext->RSSetViewports(1, &m_viewport);
return;
}
요약
마침내 DirectX를 화면의 색을 지정하여 초기화하여 생성하고 종료할 수 있게 되었다.
연습
1. 전체화면 만들어보기
ApplicationClass.h의 전역 변수인 FULL_SCREEN을 true로 바꾸어준다.
2. 노란 화면으로 창 초기화하기
3. 그래픽 카드의 이름을 텍스트 파일에 저장
나는 Application.cpp의 Initilalize함수에서 D3DClass가 초기화 된 후에 저장했다.
// 1. 쓰기 전용으로 파일 열기 (파일이 없으면 생성해 연다.)
std::ofstream myTXTfile;
myTXTfile.open("Graphic_card_name.txt");
// 파일이 정상적으로 열렸는지 확인
if (myTXTfile.is_open() == true)
{
// 2. 그래픽 카드 정보 가져와 파일에 쓰기
char GCname[128];
int VRAMsize = 0;
m_Direct3D->GetVideoCardInfo(GCname, VRAMsize);
myTXTfile << GCname;
// 3. ofstream이 자동으로 소멸돼 알아서 닫아주지만 굳이 파일 닫기를 해줬다.
myTXTfile.close();
}
저장된 파일의 위치는 해당 작업 폴더에 저장된다.
개념 정리
렌더 타겟 뷰 : DX가 그림을 그리는 버퍼 장착 칸, 보통 스왑체인의 백 버퍼 포인터와 연결된다.
StencilBuffer 는 특정 조건을 충족하는 픽셀만 렌더링되도록 할때 사용되는 버퍼다.
같은 스텐실... 혹시 불어불어 불어펜을 아시나요..?
그럼 Depth, StencilBuffer(이하 D,S buffer) 를 만들고 DX에 등록해보자.
1. 버퍼는 결국2D Texture이기에 사용할 2D Texture 생성.
// Initialize the description of the depth buffer.
ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc));
// 버퍼는 결국 2D 텍스쳐일 뿐이기에 버퍼로 사용할 2D 텍스쳐부터 만들것이다.
// Set up the description of the depth buffer.
depthBufferDesc.Width = screenWidth;
depthBufferDesc.Height = screenHeight;
depthBufferDesc.MipLevels = 1;
depthBufferDesc.ArraySize = 1;
// 32bit중 24bit는 Depth buffer로, 8bit는 Stencil buffer로 사용.
depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthBufferDesc.SampleDesc.Count = 1;
depthBufferDesc.SampleDesc.Quality = 0;
depthBufferDesc.Usage = D3D11_USAGE_DEFAULT;
depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthBufferDesc.CPUAccessFlags = 0;
depthBufferDesc.MiscFlags = 0;
// 하나의 2D Texture를 깊이, 스텐실 버퍼로 사용한다.
m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
위 코드에서 마지막 부분에 // 하나의 2D Texture를 D,S buffer로 사용한다고 하는데,
중간에 depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT의 뜻이 32bit중 24bit는 Depth buffer로, 8bit는 Stencil buffer로 사용한다는 뜻이기에 하나의 Texture에 두 개의 버퍼를 사용가능하게 해준다.
2. D,S buffer 의 동작 방법을 정의하는D3D11_DEPTH_STENCIL_DESC생성 후 등록
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
// Set up the description of the stencil state.
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = 0xFF;
depthStencilDesc.StencilWriteMask = 0xFF;
// 픽셀이 전면을 향하고 있는 경우 스텐실 작업.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// 픽셀이 후면을 향하고 있는 경우 스텐실 작업.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// depth stencil state 생성
m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
// depth stencil state 등록
m_deviceContext->OMSetDepthStencilState(m_depthStencilState, 1);
3. 런타임중 D,S buffer 에 접근할 수 있는 ID3D11DepthStencilView 생성 후 등록
// depth stencil view 초기화
ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc));
// depth stencil view Desc 설정
depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
depthStencilViewDesc.Texture2D.MipSlice = 0;
// depth stencil view 생성
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
// 렌더 타겟 뷰와 깊이 스텐실 버퍼를 출력 렌더 파이프라인에 바인딩합니다.
m_deviceContext->OMSetRenderTargets(1, &m_renderTargetView, m_depthStencilView);
위 코드의 마지막 OMSetRenderTargets은 렌더 파이프 라인의 OM단계에 배치한다는 말인데 나중에 더 자세히 알게 된다.
여기까지 Render target view와 D, S buffer를 생성 후 렌더링 파이프 라인에 배치 하였다.
중간 마감
Initialize 내용이 너무너무너무너무너무너무 길어서;;; 진짜 다음 포스팅에서 마무리한다;;;;;;;
개념 정리
스왑체인 : 두 개 이상의 버퍼를 체인처럼 연결해 프레임마다 버퍼를 교체하며 사용하는 기술.
Direct3D device(ID3D11Device) : 그래픽 리소스의 생성, 관리를 맡는 DXGI의 주 인터페이스.
특히 생성했다 하면 대부분 이 인터페이스를 사용한다.
Direct3D device context(ID3D11DeviceContext) : 그래픽 리소스를 등록하고 렌더링 명령을 하는 DXGI의 주 인터페이스.
위의 D3Ddevice로 만든 리소스들을 파이프 라인에 등록한다거나 셰이더를 등록한다거나 이런 등록이 대부분 이 인터페이스를 사용한다.
Render target view : 프레임마다 렌더링 결과물이 그려질 버퍼를 가리키는 포인터를 가진 인터페이스
bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
bool result;
// Direct3D 개체를 생성 및 초기화 합니다.
m_Direct3D = new D3DClass;
// 이 클래스의 전역 변수 4개와 창의 가로 세로 길이를 매개변수로 D3DClass의 초기화 함수를 호출한다.
// 그러면 D3DClass는 이 매개변수를 이용해 Direct3D 시스템을 설정한다.
result = m_Direct3D->Initialize( screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
if (!result)
{
MessageBox(hwnd, L"Could not initialize Direct3D", L"Error", MB_OK);
return false;
}
return true;
}
3. Shutdown
이전에 언급했듯이 특정 Windows 함수는 클래스 소멸자를 호출하지 않아 메모리 누수가 발생할 수 있기 때문에 소멸시 해야하는 작업은 이 Shutdown함수에서 담당한다.
void ApplicationClass::Shutdown()
{
// Direct3D 개체가 초기화 되었는지 확인 후 해제합니다.
if (m_Direct3D != nullptr)
{
m_Direct3D->Shutdown();
delete m_Direct3D;
m_Direct3D = 0;
}
return;
}
모든 그래픽 개체의 메모리 해제, 소멸이 여기서 발생해 마찬가지로 D3DClass 개체도 여기에서 소멸된다.
4. Frame
이제 Frame함수는 매 프레임마다 Render함수를 호출한다.
bool ApplicationClass::Frame()
{
bool result;
// 그래픽 Scene을 렌더링합니다.
result = Render();
if (result == false)
{
return false;
}
return true;
}
5. Render
화면에 그림을 그리는 함수. 아직은 별 게 없다.
bool ApplicationClass::Render()
{
// Scene을 회색으로 초기화 한다.
m_Direct3D->BeginScene(0.5f, 0.5f, 0.5f, 1.0f);
// 렌더링된 장면을 화면에 표시한다.
m_Direct3D->EndScene();
return true;
}
D3DClass.h
이 헤더파일에서는 닉값처럼 DirectX의 기능을 사용하기 위한 코드가 포함된다. 첫 부분은 라이브러리를 연결한다.
// DirectX의 라이브러리를 사용한다.
// #pragma comment : 해당 lib파일을 링크하라는 명령
#pragma comment(lib, "d3d11.lib") // 3D그래픽을 그리기 위한 모든 기능 포함
#pragma comment(lib, "dxgi.lib") // 하드웨어에 대한 정보를 얻는 기능 포함
#pragma comment(lib, "d3dcompiler.lib") // 셰이더 컴파일 기능 포함
그리고 가져온 라이브러리에서 사용하는 헤더파일을 include한다.
#include <d3d11.h>
#include <directxmath.h>
using namespace DirectX;
클래스는 지금 시간엔 단순하게 유지한다. 중요한 건 '초기화 및 종료' 이다. 이 튜토리얼의 중점이다.
이 초기화 함수는 Direct3D의 전체 설정을 수행하는 기능이다. 너무 길어 중요하다 싶은 것만 짚고 넘어간다. 먼저 매개변수를 확인한다.
bool D3DClass::Initialize(
int screenWidth, // 창의 가로 길이
int screenHeight, // 창의 세로 길이
bool vsync, // 수직 동기화 여부
HWND hwnd, // 프로그램 창의 핸들
bool fullscreen, // 전체화면의 여부
float screenDepth, // 렌더링 될 3D 환경에 대한 깊이 설정 1
float screenNear // 렌더링 될 3D 환경에 대한 깊이 설정 2
)
첫번째로 하는 것은 그래픽카드, 모니터의 정보를 통해 주사율 값을 가져와 주사율을 설정해야 한다.
그렇지 않으면 사용하는 장치보다 높은 주사율으로 설정될 수 있는데 이는 성능 저하, 디버그 출력에 오류를 발생시킨다.
※ 원문에서 나오는 디스플레이 모드란 나는 처음에 해상도만을 뜻하는 줄 알았지만 사실 해상도 뿐만아니라 주사율, 픽셀 형식 등 정보가 포함된 구조체였다. 먼저 보고가면 이해하기 수월하다.
// 디스플레이 모드
typedef struct DXGI_MODE_DESC {
UINT Width; // 화면의 가로 해상도
UINT Height; // 화면의 세로 해상도
DXGI_RATIONAL RefreshRate; // 주사율 (초당 화면 재생 빈도)
DXGI_FORMAT Format; // 픽셀 형식
DXGI_MODE_SCANLINE_ORDER ScanlineOrdering; // 프레임을 그리는 방법
DXGI_MODE_SCALING Scaling; // 스케일링 방식
}
주사율을 가져오는 방법은 꼬리를 물듯이 이어진다. 먼저 IDXGIFactory 개체를 생성한다.
// DirectX graphics Infrastructure(DXGI) 개체를 생성하고 관리하는 기능을 한다.
// DXGI는 일단 프로그램과 그래픽 기능 장치(모니터, 그래픽카드 ..) 사이에서 일해주는 기능이라고 생각하자.
IDXGIFactory* factory;
// IDXGIFactory를 생성
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
그리고 만든 IDXGIFactory 개체를 이용해 그래픽카드의 정보를 가져올 수 있는 인터페이스인 IDXGIAdapter을 생성한다.
// IDXGIAdapter : 그래픽 카드의 특정 기능과 정보를 관리하는 인터페이스
// 그래픽 카드의 정보가 나열 되고 해당 그래픽 카드와 관련된 작업을 수행 가능
IDXGIAdapter* adapter;
// 방금 만든 DXGI factory를 사용해 0번째 사용하는 그래픽카드의 IDXGIAdapter를 생성한다.
result = factory->EnumAdapters(0, &adapter);
그리고 만든 IDXGIAdapter를 이용해 그래픽 카드와 연결 된 모니터의 정보를 가져올 수 있는 IDXGIOuput을 생성한다.
// IDXGIOutput : 그래픽 카드의 출력장치(모니터, ...)의 정보를 관리하는 인터페이스
IDXGIOutput* adapterOutput;
// IDXGIAdapter를 이용해 그래픽 카드의 사용 가능한 0번째 모니터의 정보를 저장한다.
result = adapter->EnumOutputs(0, &adapterOutput);
그리고 만든 IDXGIOuput을 이용해 Display mode 종류 개수를 저장한다.
여기서 중요한건 이 함수는 마지막에 NULL이냐 아니냐에 따라 동작이 달라지는데, NULL인 경우 지원 하는 Display mode의 총 개수를 3번째 매개변수에 저장한다.
// 해상도의 개수를 저장할 uint
unsigned int numModes
// 픽셀 형식이 DXGI_FORMAT_R8G8B8A8_UNORM인 해상도의 종류 개수를 numModes에 저장한다.
// DXGI_FORMAT_R8G8B8A8_UNORM는 32비트 색상 형식으로 각 채널(R,G,B,A)가 8비트로 표현 된다는 뜻.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
아까 저장한 Display mode 개수만큼 동적 배열을 생성한다.
// 위에서 말했던 구조체!
DXGI_MODE_DESC* displayModeList;
// 방금 저장한 해상도의 종류 개수 만큼 배열을 생성한다.
displayModeList = new DXGI_MODE_DESC[numModes];
다시 한 번 GetDisplayModeList를 사용하는데 이번에 마지막에 NULL이 아닌 값을 넣는다. 이렇게 하면 마지막 매개변수 배열에 세번째 매개변수 만큼 Display mode의 정보를 채워 넣는다.
※ GetDisplayModeList는 원래 두 번 사용하게끔 설계되었다
// numModes의 수 만큼 디스플레이 모드 정보를 displayModeList으로 가져온다.
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
이제 모든 Display mode를 보면서 모니터의 크기와 맞는 모드를 찾는다. 일치하는 모드면 그 모드에 주사율 분자 분모를 저장한다.
// 디스플레이 모드 목록에서 모니터의 크기에 맞는 디스플레이 모드를 찾는다.
// 일치하는 디스플레이 모드를 찾으면 주사율의 분자 분모를 저장한다.
for (i = 0; i < numModes; i++)
{
if (displayModeList[i].Width == (unsigned int)screenWidth)
{
if (displayModeList[i].Height == (unsigned int)screenHeight)
{
numerator = displayModeList[i].RefreshRate.Numerator;
denominator = displayModeList[i].RefreshRate.Denominator;
}
}
}
이렇게 주사율 설정 값을 알아보았고 다음으로 할 것은 그래픽 카드의 이름과 vram 용량을 알아낸다.
// 그래픽 카드의 정보 구조체
DXGI_ADAPTER_DESC adapterDesc;
// DXGI_ADAPTER_DESC를 IDXGIAdapter를 통해 가져온다.
result = adapter->GetDesc(&adapterDesc);
// dedicated video card memory(VRAM)를 메가바이트 단위로 저장합니다.
m_videoCardMemory = (int)(adapterDesc.DedicatedVideoMemory / 1024 / 1024);
// 그래픽 카드의 이름을 Char형 배열로 변환하여 저장합니다.
wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
원하는 정보였던 주사율에 대한 분자 분모, 그래픽 카드의 정보를 저장했으니 사용했던 인터페이스들을 해제한다.
// Release the display mode list.
delete[] displayModeList;
displayModeList = 0;
// Release the adapter output.
adapterOutput->Release();
adapterOutput = 0;
// Release the adapter.
adapter->Release();
adapter = 0;
// Release the factory.
factory->Release();
factory = 0;
중간 마감
Initialize 내용이 너무 길어 다음 포스팅에서 마무리하고, 이번에 중점이였던 DXGI를 잠깐 짚고 간다.
DXGI(DirectX graphics intrastructure)
DXGI :애플리케이션과 그래픽 하드웨어 사이에서 그래픽 자원을 관리하고 제어하는 프레임워크
이 코드를 실행시킨 프로그램은 main → Test → main 의 흐름으로 프로그램이 실행된다. 이런게 하나의 (코드)흐름이다.
그래서 프로그램이 실행되면 코드가 실행되기는 해야하니까 무조건 하나의 흐름은 가지고 있을 수 밖에 없는데 이게 main thread라 한다.
이 main thread는 디버깅창에서도 확인할 수 있다.
● 스레드는 각 스택 영역을 가지며 힙, 데이터 영역을 공유 한다.
● 하나의 스레드는 CPU의 하나의 코어가 움직인다.
스레드 생성
thread를 include해주어야 사용할 수 있다.
#include <thread>
//스레드 개체 t 생성
std::thread t;
스레드 실행
스레드 실행은 함수를 연결해 주면 그때 부터 실행된다.
// 일반 함수
void Func() { cout<<"Hi"<<endl; };
// 스레드 t1 생성
std::thread t1;
// 스레드 t1 함수 연결하여 실행
t1 = std::thread(Func);
// 스레드 t2 생성과 동시에 함수 연결하여 실행 1
std::thread t2 = std::thread(Func)
// 스레드 t2 생성과 동시에 함수 연결하여 실행 2
std::thread t2(Func);
스레드 클래스의 멤버 함수
int main()
{
std::thread t1;
// 1.cpu의 코어 개수를 반환
int core = t1.hardware_concurrency();
// 2.스레드의 고유 ID를 반환
// 자료형이 auto인 이유는 운영체제마다 id관리하는 자료형이 달라 윈도우에선 int로 받을 수 없다.
auto id = t1.get_id(); // == std::thread::id id = t1.get_id()
// 3.t1의 스레드가 끝날때 까지 기다림
t1.join()
// 4.부모 스레드와 자식 스레드의 연결을 끊어 버림, 여기선 main과 t1의 연결을 끊는다.
t1.detach()
}
여기서 join 이라는 함수가 중요한데, main thread가 우리가 만든 다른 스레드보다 먼저 종료하면 에러가 생성된다.
