DirectX 초기화 / 삼각형 그리기

1. DirectX 초기화

stdafx.h에 추가

extern ID3D11VertexShader* VertexShader;
extern ID3D11PixelShader* PixelShader;

extern ID3D10Blob* VsBlob;
extern ID3D10Blob* PsBlob;

 

Device.cpp

void InitDirect3D(HINSTANCE hInstance) {
	// SwapChain
	DXGI_MODE_DESC bufferDesc; // 후면버퍼 속성 구조체
	ZeroMemory(&bufferDesc, sizeof(DXGI_MODE_DESC));
	bufferDesc.Width = Width;
	bufferDesc.Height = Height;
	bufferDesc.RefreshRate.Numerator = 60; // 화면 재생 빈도
	bufferDesc.RefreshRate.Denominator = 1;
	bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
	bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;	// 디스플레이 스캔라인 모드
	bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;	// 픽셀 형식(UNORM : 0~1사이의 값)

	DXGI_SWAP_CHAIN_DESC swapDesc;
	ZeroMemory(&swapDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
	swapDesc.BufferCount = 1;	// 후면 버퍼 개수
	swapDesc.BufferDesc = bufferDesc;	// 후면 버퍼 속성
	swapDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;	// 버퍼의 용도 (표면, 자원을 출력 렌더 타겟으로 지정)
	swapDesc.SampleDesc.Count = 1;	// 멀티 샘플링을 위해 추출할 표본의 개수와 품질 수준
	swapDesc.SampleDesc.Quality = 0;
	swapDesc.OutputWindow = Hwnd;	// 렌더링 결과를 출력할 윈도우
	swapDesc.Windowed = TRUE;
	swapDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;	// 이전에 그렸던 것 폐기

	// Featured Level
	vector<D3D_FEATURE_LEVEL> featured_level =
	{
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
		D3D_FEATURE_LEVEL_9_3,
		D3D_FEATURE_LEVEL_9_2,
		D3D_FEATURE_LEVEL_9_1,
	};

	// Create Device and SwapChain
	HRESULT hr = D3D11CreateDeviceAndSwapChain(
		NULL,
		D3D_DRIVER_TYPE_HARDWARE,
		NULL,
		NULL,
		featured_level.data(),
		featured_level.size(),
		D3D11_SDK_VERSION,
		&swapDesc,
		&SwapChain,
		&Device,
		NULL,
		&DeviceContext
	);
	assert(SUCCEEDED(hr));

	CreateBackBuffer();
}

void Destroy() {
	SAFE_RELEASE(PixelShader);
	SAFE_RELEASE(VertexShader);
	SAFE_RELEASE(PsBlob);
	SAFE_RELEASE(VsBlob);

	SAFE_RELEASE(SwapChain);
	SAFE_RELEASE(Device);
	SAFE_RELEASE(DeviceContext);

	DeleteBackBuffer();
}

void CreateBackBuffer() {
	//Get BackBuffer
	ID3D11Texture2D* BackBuffer;
	HRESULT hr = SwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&BackBuffer);
	assert(SUCCEEDED(hr));

	//Create RTV
	hr = Device->CreateRenderTargetView(BackBuffer, NULL, &RTV);
	assert(SUCCEEDED(hr));
	BackBuffer->Release();

	//OM Set
	DeviceContext->OMSetRenderTargets(1, &RTV, NULL);

	//Create Shader
	{
		//VSBlob
		HRESULT hr;
		hr = D3DX11CompileFromFile
		(
			L"Effect.fx", 0, 0, "VS", "vs_5_0",
			0, 0, 0,
			&VsBlob, 0, 0
		);
		assert(SUCCEEDED(hr));

		//PSBlob		
		hr = D3DX11CompileFromFile
		(
			L"Effect.fx", 0, 0, "PS", "ps_5_0",
			0, 0, 0,
			&PsBlob, 0, 0
		);
		assert(SUCCEEDED(hr));

		//Create VertexShader
		hr = Device->CreateVertexShader
		(
			VsBlob->GetBufferPointer(),
			VsBlob->GetBufferSize(),
			NULL,
			&VertexShader
		);
		assert(SUCCEEDED(hr));

		//Create PixelShader
		hr = Device->CreatePixelShader
		(
			PsBlob->GetBufferPointer(),
			PsBlob->GetBufferSize(),
			NULL,
			&PixelShader
		);
		assert(SUCCEEDED(hr));

		//Set Shader
		DeviceContext->VSSetShader(VertexShader, 0, 0);
		DeviceContext->PSSetShader(PixelShader, 0, 0);
	}

	//Create Viewport
	{
		D3D11_VIEWPORT viewPort;
		ZeroMemory(&viewPort, sizeof(D3D11_VIEWPORT));
		viewPort.TopLeftX = 0;
		viewPort.TopLeftY = 0;
		viewPort.Width = (float)Width;
		viewPort.Height = (float)Height;

		DeviceContext->RSSetViewports(1, &viewPort);
	}
}

void DeleteBackBuffer() {
	SAFE_RELEASE(RTV);
}

 

2. Main 구성

Main.cpp

#include "stdafx.h"
#include "Systems/Device.h"

ID3D11Buffer* vertexBuffer;

ID3D11InputLayout* inputLayout;
D3D11_INPUT_ELEMENT_DESC layoutDesc[] =
{
	{
		"POSITION", //SemanticName
		0,
		DXGI_FORMAT_R32G32B32_FLOAT,
		0,
		0,
		D3D11_INPUT_PER_VERTEX_DATA,
		0
	},

	{
		"COLOR", //SemanticName
		0,
		DXGI_FORMAT_R32G32B32_FLOAT,
		0,
		12,
		D3D11_INPUT_PER_VERTEX_DATA,
		0
	}
};

struct Vertex
{
	D3DXVECTOR3 Position;
	D3DXCOLOR Color;
};

void InitScene() {
	Vertex vertices[4];

	vertices[0].Position = D3DXVECTOR3(+0.5f, -0.5f, 0.0f);
	vertices[1].Position = D3DXVECTOR3(-0.5f, -0.5f, 0.0f);
	vertices[2].Position = D3DXVECTOR3(-0.5f, +0.5f, 0.0f);
	vertices[3].Position = D3DXVECTOR3(+0.5f, -0.5f, 0.0f);

	vertices[0].Color = D3DXCOLOR(1, 0, 0, 1);
	vertices[1].Color = D3DXCOLOR(1, 0, 0, 1);
	vertices[2].Color = D3DXCOLOR(1, 0, 0, 1);
	vertices[3].Color = D3DXCOLOR(1, 0, 0, 1);

	//Create VertexBuffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(D3D11_BUFFER_DESC));
		desc.Usage = D3D11_USAGE_DEFAULT;
		desc.ByteWidth = sizeof(Vertex) * 4;
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

		D3D11_SUBRESOURCE_DATA data;
		ZeroMemory(&data, sizeof(D3D11_SUBRESOURCE_DATA));
		data.pSysMem = vertices;

		HRESULT hr = Device->CreateBuffer(&desc, &data, &vertexBuffer);
		assert(SUCCEEDED(hr));
	}

	//Create InputLayout
	{
		HRESULT hr = Device->CreateInputLayout
		(
			layoutDesc,
			2,
			VsBlob->GetBufferPointer(),
			VsBlob->GetBufferSize(),
			&inputLayout
		);
		assert(SUCCEEDED(hr));
	}

}

void DestroyScene() {
	SAFE_RELEASE(inputLayout);
	SAFE_RELEASE(vertexBuffer);
}

void Update() {

}

void Render() {
	D3DXCOLOR bgcolor = D3DXCOLOR(1, 1, 1, 1);
	DeviceContext->ClearRenderTargetView(RTV, (float*)bgcolor);
	{
		UINT stride = sizeof(Vertex);
		UINT offset = 0;

		DeviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
		DeviceContext->IASetInputLayout(inputLayout);
		DeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP);

		DeviceContext->Draw(4, 0);
	}
	SwapChain->Present(0, 0);
}