C, C++/잡기장 | Notebook
[DirectX9] 텍스처(Texture) 설정
SEO HOB
2020. 1. 13. 18:50
1. 3D 게임 프로그래밍 개정판 및 DirectX SDK tutorial 참고해서 정리
2. 라이브러리 추가
2-1. Project 속성 -> Linker -> Input -> Additional Dependencies -> winmm.lib 추가
3. 아래는 tutorial 코드
/*
텍스처 설정
*/
#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>
#define SHOW_HOW_TO_USE_TCI
LPDIRECT3D9 g_pD3D = NULL; // D3D 디바이스 생성을 위한 D3D 객체
LPDIRECT3DDEVICE9 g_pd3dDevice = NULL; // 렌더링에 사용될 D3D 디바이스
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // 정점 버퍼
LPDIRECT3DTEXTURE9 g_pTexture = NULL; // 텍스처 정보
// 사용자 vertex
struct CUSTOMVERTEX
{
D3DXVECTOR3 position; // 정점의 3차원 좌표
D3DCOLOR color;
#ifndef SHOW_HOW_TO_USE_TCI
FLOAT tu, tv; // The texture coordinates
#endif
};
// Our custom FVF, which describes our custom vertex structure
#ifdef SHOW_HOW_TO_USE_TCI
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)
#else
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)
#endif
// 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 off light
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
// turn on the z-buffer
g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
return S_OK;
}
// Geometry 초기화
HRESULT InitGeometry()
{
// 파일로 부터 텍스처 생성
if (FAILED(D3DXCreateTextureFromFile(g_pd3dDevice, L"banana.bmp", &g_pTexture)))
{
// If texture is not in current folder, try parent folder
if (FAILED(D3DXCreateTextureFromFile(g_pd3dDevice, L"..\\banana.bmp", &g_pTexture)))
{
MessageBox(NULL, L"Could not find banana.bmp", L"Textures.exe", MB_OK);
return E_FAIL;
}
}
// 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].color = 0xffffffff;
#ifndef SHOW_HOW_TO_USE_TCI
pVertices[2 * i + 0].tu = ((FLOAT)i) / (50 - 1); // 텍스처의 u 좌표 : 0.0 ~ 1.0 사이의 값
pVertices[2 * i + 0].tv = 1.0f; // 텍스처의 v 좌표 : 1.0f
#endif
pVertices[2 * i + 1].position = D3DXVECTOR3(sinf(theta), 1.0f, cosf(theta));
pVertices[2 * i + 1].color = 0xff808080;
#ifndef SHOW_HOW_TO_USE_TCI
pVertices[2 * i + 1].tu = ((FLOAT)i) / (50 - 1); // 텍스처의 u 좌표 : 0.0 ~ 1.0 사이의 값
pVertices[2 * i + 1].tv = 0.0f; // 텍스처의 v 좌표 : 0.0f
#endif
}
// 정점 버퍼 unlock
g_pVB->Unlock();
return S_OK;
}
// 해제
VOID Cleanup()
{
// 해제 순서 : Texture 해제 -> VB 해제 -> D3D 디바이스 해제 -> D3D 객체 해제
if (g_pTexture != NULL)
g_pTexture->Release();
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() / 5000.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); // 생성한 프로젝션 행렬을 디바이스에 설정
}
// 화면 그리기
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()))
{
// 월드, 뷰, 프로젝션 행렬 설정
SetupMatrices();
// 여기서는 텍스처의 색깔과 정점의 색 정보를 modulate 연산으로 섞어서 출력
// (텍스처 스테이지는 여러 장의 텍스처와 색깔 정보를 섞어서 출력할 때 사용)
// 0번 텍스처 스테이지에 텍스처 등록
g_pd3dDevice->SetTexture(0, g_pTexture);
// MODULATE 연산으로 색깔을 섞음
g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
// 첫 번째 섞을 색은 텍스처 색
g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
// 두 번째 섞을 색은 정점 색
g_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
// alpha 연산은 사용하지 않음
g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
#ifdef SHOW_HOW_TO_USE_TCI
#if 0
// Note: to use D3D texture coordinate generation, use the stage state
// D3DTSS_TEXCOORDINDEX, as shown below. In this example, we are using
// the position of the vertex in camera space (D3DTSS_TCI_CAMERASPACEPOSITION)
// to generate texture coordinates. Camera space is the vertex position
// multiplied by the World and View matrices. The tex coord index (TCI)
// parameters are passed into a texture transform, which is a 4x4 matrix
// which transforms the x,y,z TCI coordinates into tu, tv texture coordinates.
// In this example, the texture matrix is setup to transform the input
// camera space coordinates (all of R^3) to projection space (-1,+1)
// and finally to texture space (0,1).
// CameraSpace.xyzw = (input vertex position) * (WorldView)
// ProjSpace.xyzw = CameraSpace.xyzw * Projection //move to -1 to 1
// TexSpace.xyzw = ProjSpace.xyzw * ( 0.5, -0.5, 1.0, 1.0 ) //scale to -0.5 to 0.5 (flip y)
// TexSpace.xyzw += ( 0.5, 0.5, 0.0, 0.0 ) //shift to 0 to 1
// Setting D3DTSS_TEXTURETRANSFORMFLAGS to D3DTTFF_COUNT4 | D3DTTFF_PROJECTED
// tells D3D to divide the input texture coordinates by the 4th (w) component.
// This divide is necessary when performing a perspective projection since
// the TexSpace.xy coordinates prior to the homogeneous divide are not actually
// in the 0 to 1 range.
D3DXMATRIXA16 mTextureTransform;
D3DXMATRIXA16 mProj;
D3DXMATRIXA16 mTrans;
D3DXMATRIXA16 mScale;
g_pd3dDevice->GetTransform(D3DTS_PROJECTION, &mProj);
D3DXMatrixTranslation(&mTrans, 0.5f, 0.5f, 0.0f);
D3DXMatrixScaling(&mScale, 0.5f, -0.5f, 1.0f);
mTextureTransform = mProj * mScale * mTrans;
g_pd3dDevice->SetTransform(D3DTS_TEXTURE0, &mTextureTransform);
g_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);
g_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
#else
D3DXMATRIXA16 mat;
mat._11 = 0.25f;
mat._12 = 0.00f;
mat._13 = 0.00f;
mat._14 = 0.00f;
mat._21 = 0.00f;
mat._22 = -0.25f;
mat._23 = 0.00f;
mat._24 = 0.00f;
mat._31 = 0.00f;
mat._32 = 0.00f;
mat._33 = 1.00f;
mat._34 = 0.00f;
mat._41 = 0.50f;
mat._42 = 0.50f;
mat._43 = 0.00f;
mat._44 = 1.00f;
// 텍스처 변환 행렬
g_pd3dDevice->SetTransform(D3DTS_TEXTURE0, &mat);
// 2차원 텍스처 사용
g_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
// 카메라 좌표계 변환
g_pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
#endif
#endif
// 정점 정보가 담겨있는 정점 버퍼를 출력 스트림으로 할당
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 05: Textures",
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;
}