[DirectX9] 광원(light) 설정

1. 3D 게임 프로그래밍 개정판 및 DirectX SDK tutorial 참고해서 정리

2. 라이브러리 추가

 2-1. Project 속성 -> Linker -> Input -> Additional Dependencies -> winmm.lib 추가

3. 아래는 tutorial 코드

/*
광원(light) 설정
*/

#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>

LPDIRECT3D9             g_pD3D = NULL; // D3D 디바이스 생성을 위한 D3D 객체
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // 렌더링에 사용될 D3D 디바이스
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // 정점 버퍼


// 사용자 vertex
struct CUSTOMVERTEX
{
	D3DXVECTOR3 position; // 정점의 3차원 좌표
	D3DXVECTOR3 normal; // 정점의 법선벡터
};


// FVF 값
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL)


// Direct3D 초기화
HRESULT InitD3D(HWND hWnd)
{
	// D3DDevice 생성을 위한 D3D 객체 생성
	if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
		return E_FAIL;

	D3DPRESENT_PARAMETERS d3dpp; // 디바이스 생성을 위한 파라미터
	ZeroMemory(&d3dpp, sizeof(d3dpp)); // 구조체 초기화
	d3dpp.Windowed = TRUE; // 창모드로 생성
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // SWAP 효과
	d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; // 후면버퍼 픽셀 포맷
	d3dpp.EnableAutoDepthStencil = TRUE; // z 버퍼 사용 여부
	d3dpp.AutoDepthStencilFormat = D3DFMT_D16; // z 버퍼 형식

	// D3DDevice 생성
	if (FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, // display adapter 설정 : 기본 화면 사용
		D3DDEVTYPE_HAL, // 출력 디바이스 종류 선택 : HW 가속 사용
		hWnd, // 디바이스가 출력할 윈도우 핸들
		D3DCREATE_SOFTWARE_VERTEXPROCESSING, // vertex 처리 방식 선택 : H/W or S/W
		&d3dpp, // 디바이스 생성을 위한 파라미터
		&g_pd3dDevice))) // 생성된 IDirect3DDevice9 장치 획득
	{
		return E_FAIL;
	}

	// Device state would normally be set here

	// turn off culling
	g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

	// turn on the z-buffer
	g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

	return S_OK;
}


// Geometry 초기화
HRESULT InitGeometry()
{
	// FVF를 지정하여 보관할 데이터의 형식 지정
	if (FAILED(g_pd3dDevice->CreateVertexBuffer(50 * 2 * sizeof(CUSTOMVERTEX), // 생성할 정점 버퍼의 크기
		0, // 정점 버퍼의 처리 방식
		D3DFVF_CUSTOMVERTEX, // FVF 플래그 값
		D3DPOOL_DEFAULT, // 정점 버퍼가 저장될 메모리 위치와 관리방식 지정
		&g_pVB, // 반환될 정점 버퍼
		NULL)))
	{
		return E_FAIL;
	}

	// 정점 버퍼 메모리
	CUSTOMVERTEX* pVertices;

	// 정점 버퍼 메모리 할당 : lock
	if (FAILED(g_pVB->Lock(0, // lock을 할 버퍼의 시작점
		0, // lock을 할 버퍼의 크기
		(void**)&pVertices, // 읽고 쓸수 있게 된 메모리 영역의 포인터
		0))) // lock을 수행할 때 사용하는 플래그
		return E_FAIL;

	// 실린더 만들기
	for (DWORD i = 0; i < 50; i++)
	{
		FLOAT theta = (2 * D3DX_PI * i) / (50 - 1);
		pVertices[2 * i + 0].position = D3DXVECTOR3(sinf(theta), -1.0f, cosf(theta)); // 실린더의 아래쪽 원통의 좌표
		pVertices[2 * i + 0].normal = D3DXVECTOR3(sinf(theta), 0.0f, cosf(theta)); // 실린더 아래쪽 원통의 법선벡터
		pVertices[2 * i + 1].position = D3DXVECTOR3(sinf(theta), 1.0f, cosf(theta)); // 실린더 위쪽 원통의 좌표
		pVertices[2 * i + 1].normal = D3DXVECTOR3(sinf(theta), 0.0f, cosf(theta)); // 실린더 위쪽 원통의 법선벡터
	}

	// 정점 버퍼 unlock
	g_pVB->Unlock();

	return S_OK;
}


// 해제
VOID Cleanup()
{
	// 해제 순서 : VB 해제 -> D3D 디바이스 해제 -> D3D 객체 해제

	if (g_pVB != NULL)
		g_pVB->Release();

	if (g_pd3dDevice != NULL)
		g_pd3dDevice->Release();

	if (g_pD3D != NULL)
		g_pD3D->Release();
}


// 월드, 뷰, 프로젝션 행렬 설정
VOID SetupMatrices()
{
	// 월드 행렬
	D3DXMATRIXA16 matWorld;
	D3DXMatrixIdentity(&matWorld);
	D3DXMatrixRotationX(&matWorld, timeGetTime() / 500.0f); // X축을 회전축으로 회전행렬 생성
	g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld); // 생성한 회전 행렬을 월드 행렬로 디바이스에 설정
	
	D3DXVECTOR3 vEyePt(0.0f, 3.0f, -5.0f); // 눈의 위치 : (0, 3.0, -5.0)
	D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f); // 눈이 바라 보는 위치 (0, 0, 0)
	D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f); // up 벡터 (0, 1, 0)
	D3DXMATRIXA16 matView; // 뷰 행렬
	D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec); // 뷰 행렬 설정
	g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView); // 생성한 뷰 행렬을 디바이스에 설정

	D3DXMATRIXA16 matProj; // 프로젝션 행렬
	FLOAT fFOV = D3DX_PI / 4; // FOV : 45도
	FLOAT fAspectRatio = 1.0f; // 종횡비
	FLOAT fNearClip = 1.0f; // 근접 클리핑 평면
	FLOAT fFarClip = 100.0f; // 원거리 클리핑 평면
	D3DXMatrixPerspectiveFovLH(&matProj, fFOV, fAspectRatio, fNearClip, fFarClip); // 프로젝션 행렬 생성
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj); // 생성한 프로젝션 행렬을 디바이스에 설정
}


// Light 설정
VOID SetupLights()
{
	// material 설정 : material은 단 하나만 설정 가능
	D3DMATERIAL9 mtrl;
	ZeroMemory(&mtrl, sizeof(D3DMATERIAL9));

	// yellow
	mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
	mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
	mtrl.Diffuse.b = mtrl.Ambient.b = 0.0f;
	mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
	g_pd3dDevice->SetMaterial(&mtrl);

	// light(광원) 설정
	D3DXVECTOR3 vecDir;
	D3DLIGHT9 light; // light 구조체
	ZeroMemory(&light, sizeof(D3DLIGHT9));

	light.Type = D3DLIGHT_DIRECTIONAL; // light 종류 : 점, 방향성, 스포트라이트
	light.Diffuse.r = 1.0f;
	light.Diffuse.g = 1.0f;
	light.Diffuse.b = 1.0f;

	// light 방향
	vecDir = D3DXVECTOR3(cosf(timeGetTime() / 350.0f),
		1.0f,
		sinf(timeGetTime() / 350.0f));
	D3DXVec3Normalize((D3DXVECTOR3*)&light.Direction, &vecDir);

	light.Range = 1000.0f; // light가 다다를 수 있는 최대 거리
	g_pd3dDevice->SetLight(0, &light); // 디바이스에 0번 light 설정
	g_pd3dDevice->LightEnable(0, TRUE); // 0번 light ON
	g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE); // light 설정 ON

	g_pd3dDevice->SetRenderState(D3DRS_AMBIENT, 0x00202020); // ambient 값 설정
}


// 화면 그리기
VOID Render()
{
	// backbuffer, z-buffer를 흰색으로 클리어
	g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255, 255, 255), 1.0f, 0);

	// 렌더링 시작 : scene을 그리겠다고 알림
	if (SUCCEEDED(g_pd3dDevice->BeginScene()))
	{
		// light, material 설정
		SetupLights();

		// 월드, 뷰, 프로젝션 행렬 설정
		SetupMatrices();

		// 정점 정보가 담겨있는 정점 버퍼를 출력 스트림으로 할당
		g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));

		// 정점 포맷을 디바이스에 지정
		g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);

		// 정점 버퍼의 정보 그리기
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2 * 50 - 2);

		// 렌더링 종료 : scene을 끝낸다고 알림
		g_pd3dDevice->EndScene();
	}

	// backbuffer를 화면에 표현
	g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}


// 윈도우 메시지 핸들러
LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch (msg)
	{
	case WM_DESTROY:
		Cleanup();
		PostQuitMessage(0);
		return 0;
	}

	return DefWindowProc(hWnd, msg, wParam, lParam);
}


INT WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, INT)
{
	// 윈도우 클래스
	WNDCLASSEX wc =
	{
		sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
		GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
		L"D3D Tutorial", NULL
	};

	// 윈도우 클래스 등록
	RegisterClassEx(&wc);

	// application 윈도우 생성
	HWND hWnd = CreateWindow(L"D3D Tutorial", L"D3D Tutorial 04: Lights",
		WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
		NULL, NULL, wc.hInstance, NULL);

	// Direct3D 초기화
	if (SUCCEEDED(InitD3D(hWnd)))
	{
		// Create the vertex buffer
		if (SUCCEEDED(InitGeometry()))
		{
			// Show the window
			ShowWindow(hWnd, SW_SHOWDEFAULT);
			UpdateWindow(hWnd);

			// Enter the message loop
			MSG msg;
			ZeroMemory(&msg, sizeof(msg));
			while (msg.message != WM_QUIT)
			{
				if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
				{
					// 메시지 큐에 메시지가 있으면 메시지 처리

					TranslateMessage(&msg);
					DispatchMessage(&msg);
				}
				else
				{
					// 처리할 메시지가 없는 경우 Render() 함수 호출

					Render();
				}
			}
		}
	}

	// 등록된 클래스 해제
	UnregisterClass(L"D3D Tutorial", wc.hInstance);
	return 0;
}