From YYpBD's MediaWiki
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 780번
제 목:[번역] DirectX Graphics #1
올린이:날래미 (조명근 ) 01/06/04 13:03 읽음:575 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 112
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/9(월) 15:05
◎ 조회: 1064 회
DirectX Graphics Tutorial 1
/////////////////////////////////////////////////////////////////////////////
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 1 : Device 생성
//
// 번역 : 넷츠고 게임제작동호회 - conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
/////////////////////////////////////////////////////////////////////////////
<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 1 : Device 생성 >>>>>>>
<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>
Microsoft Direct3D 를 사용하기 위해서 먼저 애플리케이션 윈도우를 생성해야한다,
그런다음 Direct3D 객체를 생성하고 초기화 하여야 한다. 객체를 조작하기 위한
구현을 위해서 그리고 장면을 render하기 위해서 요구되는 다른 객체들을 생성하기
위해서 COM 인터페이스를 사용한다. 이 튜토리얼의 기초로 하는 CreateDevice 샘플
프로젝트는 Direct3D 디바이스 생성하고 파랑색 장면을 render함으로서 이 작업을
설명한다.
이 튜토리얼은 Direct3D를 초기화하고 장면을 render하고 결국은 종료하는 다음
단계를 사용할 것이다.
* 단계 1 : 윈도우 생성
* 단계 2 : Direct3D를 초기화
* 단계 3 : 시스템 메시지 처리
* 단계 4 : 장면을 rendering하고 display하기
* 단계 5 : 종료하기
(메모)
CreateDevice 샘플 프로젝트는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut01_CreateDevice에 있습니다.
************************************
******* 단계 1 : 윈도우 생성 *******
************************************
어떤 Microsoft Windows 애플리케이션이 실행될 때 해야만 하는 첫번째는
유저에게 display하기 위해서 애플리케이션 윈도우를 생성하는 것이다. 이것을 하기
위해서 CreateDevice 샘플 프로젝트는 WinMain 함수에서 실시한다. 다음 샘플 코드는
윈도우 초기화를 수행한다.
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
// 윈도우 클래스를 등록한다.
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
"D3D Tutorial", NULL };
RegisterClassEx( &wc );
// 애플리케이션의 윈도우를 생성한다.
HWND hWnd = CreateWindow( "D3D Tutorial", "D3D Tutorial 01: CreateDevice",
WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
GetDesktopWindow(), NULL, wc.hInstance, NULL );
앞의 코드 샘플은 표준 윈도우 프로그래밍이다. 이 샘플은 "D3D Tutorial"으로
불리는 윈도우 클래스를 정의하고 등록함으로 시작한다. 클래스가 등록된 후에 이
샘플 코드는 클라이언트 영역이 300 * 300 로 등록된 클래스를 사용하여 기본적인
top-level 윈도우를 생성한다. 이 윈도우는 메뉴나 차일드 윈도우가 없다. 이 샘플은
윈도우 된 애플리케이션에 일반적인 최소 최대 그리고 종료 버튼을 포함하는
윈도우를 생성하기 위해 WS_OVERLAPPEDWINDOW 윈도우 스타일을 사용한다. ( 만약 이
샘플이 풀 스크린 모드에서 동작하기 위한 것이었다면 우선된 윈도우 스타일은
WS_EX_TOPMOST 이다. WS_EX_TOPMOST는 생성된 윈도우가 모든 non-topmost 윈도우
위에 배치되어야 하고 심지어 윈도우가 비활성화 될 때에도 그것들 위에 머물러야
하도록 설정한다.)
애플리케이션 윈도우가 준비되면 '단계 2 : Direct3D를 초기화'에서 설명되어 있는
것처럼 극히 중요한 Microsoft Direct3D 객체를 셋업하는 것을 시작할 수 있다.
******************************************
******* 단계 2 : Direct3D를 초기화 *******
******************************************
CreateDevice 샘플 프로젝트는 윈도우가 생성된 후에 WinMain으로부터 호출되는
InitD3D 애플리케이션 정의 함수에서 Microsoft Direct3D 초기화를 수행한다.
애플리케이션 윈도우를 생성한 후에 장면을 render하기 위해 사용될 Direct3D 객체를
초기화 할 준비가 되었다. 이 과정은 Direct3D 객체를 생성하고 presentation
parameter들을 설정하고 마지막으로 Direct3D device를 생성하는 것을 포함한다.
Direct3D 객체를 생성한 후에 Direct3D device를 생성하기 위해서
IDirect3D8::CreateDevice 메소드를 사용할 수 있다.. 또한 device, type, mode
등등을 나열하기 위해서 Direct3D 객체를 사용할 수 있다. 아래 코드 조각은
Direct3DCreate8 함수로 Direct3D 객체를 생성한다.
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
Direct3DCreate8 에 전달되는 오직 한 개의 인자는 D3D_SDK_VERSION이 되어야 한다.
이것은 Direct3D에서 정확한 헤더 파일이 사용되고 있음을 알려준다. 이 값은 헤더나
다른 변화가 애플리케이션의 수정을 요구할 때는 언제라도 증가된다. 만약 버젼이
맞지 않는다면 Direct3DCreate8은 실패할 것이다.
다음 단계는 아래 코드 조각에서 보이는 것 처럼 IDirect3D8::GetAdapterDisplayMode
메소드를 사용함으로서 현재 디스플레이 모드를 회수하는 것이다.
D3DDISPLAYMODE d3ddm;
if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return E_FAIL;
D3DDISPLAYMODE 구조체의 Format 맴버는 Direct3D device를 생성할 때 사용될
것이다. 윈도우 모드에서 수행하기 위해서 Format 맴버는 어댑터의 현재 모드에
맞추어진 백버퍼를 생성하기 위해 사용될 것이다.
D3DPRESENT_PARAMETERS의 필드를 채움으로서 3D Application이 어떻게 작용하기를
바라는 설정할 수 있다. CreateDevice 샘플 프로젝트는 Windowed 맴버에 TRUE를
SwapEffect 맴버에 D3DSWAPEFFECT_DISCARD를 BackBufferFormat 맴버에
d3ddm.Format를 설정한다.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
마지막 단계는 다음 코드 예제에서 설명하는 것처럼 Direct3D device를 생성하기
위해 IDirect3D8::CreateDevice 매소드를 사용하는 것이다.
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
앞의 코드 샘플은 D3DADAPTER_DEFAULT 플래그를 사용함으로 default 어댑터로
device를 생성한다. 만약 복수개의 그래픽 하드웨어를 설치하지 않았다면 대부분의
경우 시스템은 오직 한 개의 어댑터를 가지고 있을 것이다. DeviceType 인자에
D3DDEVTYPE_HAL 을 설정함으로서 소프트웨어 디바이스 보다 하드웨어 디바이스를
택하도록 지시해라. 이 코드 샘플은 시스템에게 software vertex processing을
사용하도록 전하기 위해 D3DCREATE_SOFTWARE_VERTEXPROCESSING 을 사용한다. 만약
D3DCREATE_HARDWARE_VERTEXPROCESSING 을 설정함으로 시스템에게 hardware vertex
processing 을 사용하도록 전한다면 hardware vertex processing을 지원하는 비디오
카드에서 현저한 수행 증가를 볼 것임을 주목하라.
Direct3D 가 초기화되었으므로, 다음 단계는 '단계 3 : 시스템 메시지 처리'에서
설명한 것처럼 시스템 메시지를 처리하기 위한 메커니즘을 보증하는 것이다.
*******************************************
******* 단계 3 : 시스템 메시지 처리 *******
*******************************************
애플리케이션 윈도우를 생성하고 Microsoft Direct3D를 초기화 한 후에 장면을
render할 준비가 되었다. 대부분의 경우 Microsoft Windows 애플리케이션은 그들의
메시지 루프에서 시스템 메시지를 감시한다. 그리고 그들은 큐 안에 어떤 메시지도
없을 때에는 언제라도 프레임을 render한다. 그러나 CreateDevice 샘플 프로젝트는
윈도우의 모든 부분이나 부분을 다시 그려야 할 필요가 있음을 애플리케이션에게
전하는 WM_PAINT 메시지가 큐 안에 있을 때까지 기다린다.
// 메시지 루프
MSG msg;
while( GetMessage( &msg, NULL, 0, 0 ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
루프가 동작하는 매 순간 DispatchMessage는 큐 안에 메시지를 처리하는 MsgProc을
호출한다. WM_PAINT가 큐안에 있게 될 때 애플리케이션은 윈도우를 다시 그릴
애플리케이션 정의 함수 Render를 호출한다. 그 때 Microsoft Win32 함수
ValidateRect가 전체 클라이언트 영역을 유효하게 하기 위해 호출된다.
메시지 처리 함수를 위한 샘플 코드는 다음과 같다.
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
switch( msg )
{
case WM_DESTROY:
PostQuitMessage( 0 );
return 0;
case WM_PAINT:
Render();
ValidateRect( hWnd, NULL );
return 0;
}
return DefWindowProc( hWnd, msg, wParam, lParam );
}
애플리케이션이 시스템 메시지를 처리하므로 다음 단계는 '단계 4 : 장면을
rendering하고 display하기'애서 설명하는 것처럼 display를 render하는 것이다.
********************************************************
******* 단계 4 : 장면을 rendering하고 diplay하기 *******
********************************************************
장면을 rendering하고 display하기 위해서 이 단계에서 샘플 코드는 백버퍼를
파랑색으로 clear하고 백버퍼의 내용을 프론트버퍼로 옮긴다. 그리고 프론트버퍼를
스크린으로 present한다.
장면을 clear하기 위해서 IDirect3DDevice8::Clear 메소드를 호출한다.
// 백퍼버를 파랑색으로 clear한다.
g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 )
;
Clear에 의해 받아들여지는 첫번째 두 인자는 Microsoft Direct3D에게 지워질 사각형
배열의 크기와 주소를 알려준다. 사각형 배열은 지워질 render target surface 안에
영역을 표현한다.
대부분의 경우 전체 rendering target을 덮는 하나의 사각형을 사용한다. 첫번째
인자에 0을 설정하고 두번째 인자에 NULL을 설정함으로서 이것을 한다. 세번째
인자는 메소드의 작용을 결정한다. render-target surface, 연결된 깊이 버퍼,
스텐실 버퍼, 또는 세개의 어떤 조합을 지우기 위하여 플래그를 설정할 수 있다. 이
튜토리얼은 깊이 버퍼를 사용하지 않는다. 그래서 D3DCLEAR_TARGET 라는 오직 하나의
플래그만 사용된다. 나머지 세개의 인자는 render target, 깊이 버퍼, 그리고 스텐실
버퍼를 위한 지울 값을 반영하기 위해 설정한다. CreateDevice 샘플 프로젝트는
render target surface를 위해 파랑(D3DCOLOR_XRGB(0,0,255))으로 지울 색을
설정한다. 마지막 두개의 인자는 부합하는 플래그가 present하지 않기 때문에 Clear
메소드에 의해 무시된다.
뷰포트를 지운 후에 CreatDevice 샘플 프로젝트는 Direct3D에서 rendering이 시작될
것을 알려준다. 그런다음 다음 코드 조각에서 보이는 것처럼 rendering이
완료되었다는 신호를 낸다.
// 장면을 시작한다.
g_pd3dDevice->BeginScene();
// 여기에 발생한 장면 객체를 rendering한다.
// 장면을 마친다.
g_pd3dDevice->EndScene();
IDirect3DDevice8::BeginScene와 IDirect3DDevice8::EndScene 메소드는 rendering이
시작되거나 완료될 때 시스템에 신호를 낸다. 오직 이 메소드들이 호출되는
사이에서만 rendering 메소드들을 사용할 수있다. 심지어 rendering 메소드는
실패할지라도 BegineScene을 다시 호출하기 전에 EndScene을 호출해야만 한다.
장면을 rendering 후에 IDirect3DDevice8::Present 를 사용하므로서 그것을 display
한다.
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
Present에 의해 받아들여지는 첫번째 두 인자는 source 사각형과 destination
사각형이다. 이 단계에 샘플 코드는 이 두 인자에 NULL을 설정함으로서 전체
백버퍼를 프론트버퍼로 present한다. 세번째 인자는 이 presentation을 위한
destination 윈도우를 설정한다. 이 인자가 NULL로 설정되었기 때문에
D3DPRESENT_PARAMETERS 의 hWndDeviceWindow 맴버가 사용된다. 네번째 인자는
DirtyRegion 인자이다. 그리고 대부분의 경우에 NULL로 설정되어야만 한다.
이 튜토리얼의 마지막 단계는 '단계 5 : 종료하기'에서 설명된 것처럼
애플리케이션을 종료하는 것이다.
*********************************
******* 단계 5 : 종료하기 *******
*********************************
실행하는 동안 몇몇 지점에서 애플리케이션은 종료되어야만 한다. Microsoft DirectX
애플리케이션은 애플리케이션 윈도우를 destroy하는 것을 의미하는 것뿐만 아니라
애플리케이션이 사용하는 어떤 DirectX 객체라도 해제해야 한다. 그리고 그들의
포인터를 무효화해야 한다. CreateDevice 샘플 프로젝트는 이 처리를 위해
WM_DESTORY 메시지를 받았을 때 애플리케이션 정의 함수인 Cleanup을 호출한다.
VOID Cleanup()
{
if( g_pd3dDevice != NULL)
g_pd3dDevice->Release();
if( g_pD3D != NULL)
g_pD3D->Release();
}
앞의 함수는 각 객체를 위한 IUnknown::Release 메소드를 호출함으로서
애플리케이션이 사용한 DirectX 객체를 해제한다. 이 튜토리얼이 COM 규칙을 따르기
때문에 대부분의 객체를 위한 레퍼런스 카운터가 0이 되어야만 한다. 그리고
자동적으로 메모리롭터 지워질 것이다.
종료에 더하여 유저가 데스크탑의 해상도나 컬러깊이를 바꾸었을 경우같은 일반
수행하는 동안 경우도 있다. 그 때 Microsoft Direct3D 객체를 사용중에 destroy하고
다시 생성해야 할 필요가 있다. 그러므로 필요가 생길 때마다 호출할 수 있도록
한장소에 애플리케이션의 cleanup 코드를 유지하는 것이 좋은 생각이다.
이 튜토리얼은 어떻게 device를 생성하는 가를 보여주었다. '튜토리얼 2 : 정점을
rendering하기'는 기하학 모양을 그리기 위해 정점을 사용하는 방법을 보여준다.
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 781번
제 목:[번역] DirectX Graphics #2
올린이:날래미 (조명근 ) 01/06/04 13:06 읽음: 89 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 113
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/9(월) 19:37
◎ 조회: 370 회
DirectX Graphics Tutorial 2
///////////////////////////////////////////////////////////////////////////////
/
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 2 : 정점을 Rendering하기
//
// 번역 : 넷츠고 게임제작동호회 conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
///////////////////////////////////////////////////////////////////////////////
/
<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 2 : 정점을 Rendering 하기 >>>>>>>
<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>
Microsoft Direct3D로 작성된 애플리케이션들은 기하학 모양을 그리기 위해 정점을
사용한다. 각각의 3D 장면은 하나 또는 그 이상의 이런 기하학 모양을 포함한다.
정점 예제 프로젝트는 가장 간단한 모양인 삼각형을 생성하고 그것을 display에
render한다.
이 튜토리얼은 다음 단계로 삼각형을 생성하기 위해 정점을 사용하는 방법을
보여준다.
* 단계 1 : Custom 정점 유형을 정의하기
* 단계 2 : 정점 버퍼를 설정하기
* 단계 3 : display를 rendring
(메모)
정점 샘플 프로젝트의 경로는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut02_Vertices 입니다.
****************************************************
******* 단계 1 : Custom 정점 유형을 정의하기 *******
****************************************************
정점 샘플 프로젝트는 세 점을 사용함으로서 2D 삼각형을 render한다. 이것은 정점
버퍼의 개념을 소개한다. 정점 버퍼는 정점을 저장하고 render하는 Microsoft
Direct3D 객체입니다. 정점들은 custom 정점 구조체와 해당하는 custom flexible
vector format(FVF)를 지정함으로서 많은 방법으로 정의 될 수 있다. 정점 샘플
프로젝트에서의 정점의 형식은 다음 코드 조각을 보자.
struct CUSTOMVERTEX
{
FLOAT x, y, z, rhw; // 정점을 위한 transform된 위치.
DWORD color; // 정점 컬러.
};
위의 구조체는 custom 정점 유형의 형식을 설정한다. 다음 단계는 정점 버퍼에서
정점들의 항목을 설명하기 위한 FVF를 정하는 것이다. 다음 코드 조각은 위에서
만들어진 custom 정점 유형에 일치하는 FVF정의한다.
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
flexible vertex format 플래그는 어떤 형식의 custom 정점이 사용되고 있는지를
표현한다. 위의 샘플 코드는 D3DFVF_XYZRHW 와 D3DFVF_DIFFUSE 플래그를 사용한다.
그리고 그것은 정점 버퍼에게 custom 정점 형식이 transform된 점을 가지고 컬러
요소가 따라온다는 것을 전달한다.
custom 정점 형식과 FVF가 지정되었으므로, 다음 단계는 '단계 2 : 정점 버퍼를
설정하기'에서 설명된 것처럼 정점들을 가지고 정점 버퍼를 채우는 것이다.
(메모)
정점 샘플 프로젝트에서의 정점들은 transform되어 있다. 바꾸어 말하면 이미 2D
윈도우 좌표에 있다는 것이다. 이것은 점(0, 0)은 top-left 구석에 있고 양의 x축은
오른쪽이고 양의 y축은 아래라는 것을 의미한다. 이 정점들은 또한 빛을 받았다.
이것은 정점들이 Direct3D lighting을 사용하지 않고 자기 자신의 색깔을 지원하고
있다는 것을 의미한다.
*********************************************
******* 단계 2 : 정점 버퍼를 설정하기 *******
*********************************************
custom 정점 형식이 정의되었으므로 정점들을 초기화할 시간이 되었다. 정점 샘플
프로젝트는 유구되는 Microsoft Direct3D 객체를 생성한 후에 애플리케이션 정의
함수 InitVB를 호출함으로써 이를 행한다. 다음 코드 조각은 세개의 custom 정점들을
위한 값을 초기화한다.
CUSTOMVERTEX g_Vertices[] =
{
{ 150.0f, 50.0f, 0.5f, 1.0f, 0xffff0000, }, // x, y, z, rhw, color
{ 250.0f, 250.0f, 0.5f, 1.0f, 0xff00ff00, },
{ 50.0f, 250.0f, 0.5f, 1.0f, 0xff00ffff, },
};
앞의 코드 조각은 삼각형의 점을 가진 세 정점을 채우고 각각 정점이 발하는 컬러를
지정한다. 첫번째 점은 (150, 50)이고 빨강색(0xffff0000)을 발한다. 두번째 점은
(250, 250)이고 녹색(0xff00ff00)을 발한다. 세번째 점은 (50, 250)이고
파랑-녹색(0xff00ffff)을 발한다. 이 점들의 각각은 깊이 값 0.5를 가지고 1.0의
RHW을 가진다. 이 정점 형식에 대한 더 많은 정보를 위해서 Transformed and Lit
Vertices 를 보아라.
다음 단계는 다음 코드 조각에서 보여진 것처럼 정점 버퍼를 생성하기 위해
IDirect3DDevice8::CreateVertexBuffer 를 호출하는 것이다.
if( FAILED( g_pd3dDevice->CreateVertexBuffer( 3*sizeof(CUSTOMVERTEX),
0 /* 어법 */,
D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &g_pVB ) ) )
return E_FAIL;
CreateVertexBuffer의 첫번째 두 인자는 Direct3D에 원하는 크기와 새로운 정점
버퍼에 관한 원하는 어법을 전달한다. 다음 두 인자는 정점 형식과 새 버퍼를 위한
메모리 위치를 명시한다. 여기 정점 형식은 D3DFVF_CUSTOMVERTEX이다. 그리고 그것은
샘플 코드가 더 일찍 지정했던 FVF이다. D3DPOOL_DEFAULT 플래그는 Direct3D에게 이
버퍼를 위한 가장 적합한 메모리 할당에 정점 버퍼를 생성할 것을 전달한다. 마지막
인자는 생성할 정점 버퍼의 주소이다.
아래 코드 조각에 보여진 것처럼 정점 버퍼를 생성한 후에 custom 정점들로부터
정보로 채워진다.
VOID* pVertices;
if( FAILED( g_pVB->Lock( 0, sizeof(g_Vertices), (BYTE**)&pVertices, 0 ) ) )
return E_FAIL;
memcpy( pVertices, g_Vertices, sizeof(g_Vertices) );
g_pVB->Unlock();
정점 버퍼는 먼저 IDirect3DVertexBuffer8::Lock를 호출함으로서 잠겨진다. 첫번째
인자는 잠그기 위한 정점 정보안에 오프셋이다. 두번째 인자는 잠그기 위한 정점
정보의 바이트 크기이다. 세번째 인자는 정점 정보에 한 포인터로 채워진 BYTE
포인터의 주소이다. 네번째 인자는 정보를 잠그는 방법을 정점 버퍼에게 전달한다.
정점들은 그런다음 memcpy를 사용함으로 정점 버퍼로 복사되었다. 정점들이 정점버퍼
안에 들어간 후에 호출은 정점 버퍼를 열기 위해 IDirect3DVertexBuffer8::Unlock 로
만들어진다. 이 잠금과 열기 메커니즘은 정점 버퍼가 device 메모리 안에 있게
될지도 모르기 때문에 요구되는 것이다.
정점 버퍼가 정점들로 채워졌으므로 '단계 3 : display를 rendering하기'에서 설명된
것처럼 display를 render할 시간이 되었다.
************************************************
******* 단계 3 : display를 rendering하기 *******
************************************************
정점 버퍼가 정점들로 채워졌으므로 display 를 render할 시간이 되었다. display를
render하는 것은 백버퍼를 파랑색으로 clear하고 그런다음 BeginScene을 호출하는
것으로서 시작된다.
g_pd3dDevice->Clear(0,NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0L);
g_pd3dDevice->BeginScene();
정점 버퍼로부터 정점 정보를 render하는 것은 조금의 단계가 요구된다. 첫번째,
스트림 소스를 설정하는 것이 필요하다. 이 경우에 스크림 0을 사용한다. 이
스트림의 소스는 IDirect3DDevice8::SetStreamSource을 호출함으로서 지정된다.
g_pd3dDevice->SetStreamSource( 0, g_pVB, sizeof(CUSTOMVERTEX) );
SetStreamSource의 첫번째 인자는 Microsoft Direct3D에게 device 정보 스트림의
소스를 전달한다. 두번재 인자는 정보 스트림에게 묶히게 될 정점 버퍼이다. 세번째
인자는 구성 요소의 바이트 크기이다. 위의 샘플 코드에서 CUSTOMVERTEX의 크기는
구성 요소의 크기를 위해 사용되었다.
다음 단계는 IDirect3DDevice8::SetVertexShader를 호출함으로서 어떤 정점 쉐이더가
사용될지를 Direct3D가 알도록 시키는 것이다. Full, custom 정점 쉐이더들은
진보적인 논제이다. 그러나 대부분의 경우에 정점 쉐이더는 오직 FVF 코드만 있다.
이것은 어떤 형식의 정점들이 취급될지를 Direct3D가 알도록 시킨다. 다음 코드
조각은 정점 쉐이더를 설정한다.
g_pd3dDevice->SetVertexShader( D3DFVF_CUSTOMVERTEX );
SetVertexShader를 위한 오직 한개의 인자가 사용할 정점 쉐이터를 위한 핸들이다.
이 인자를 위한 값은 IDirect3DDevice8::CreateVertexShader에 의해 리턴된 핸들이나
FVF코드가 될 수 있다. D3DFVF_CUSTOMVERTEX로 정의된 FVF 코드가 사용된다.
정점 쉐이더에 관한 더 많은 정보를 위해서 Vertex shaders를 보아라.
다음 단계는 다음 코드 조각에서 보여진 것처럼 정점 버퍼안에 정점들을 render하기
위해 IDirect3DDevice8::DrawPrimitive를 사용하는 것이다.
g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 1 );
DrawPrimitive에 의해 받아들여지는 첫번째 인자는 Direct3D에게 그려질 어떤 형식의
프리미티브가 무엇인지를 전달하는 플래그이다. 이 샘플은 삼각형의 리스트를
지정하기 위해서 D3DPT_TRIANGLELIST 플래그를 사용한다. 두번째 인자는 불러들일
첫번째 정점의 인덱스이다. 세번째 인자는 그려질 프리미티브의 숫자를 전달한다. 이
샘플이 오직 하나의 삼각형을 그리기 때문에 이 값은 1로 설정된다.
다른 종류의 프리미브에 관한 좀더 많은 정보를 위해서 3-D Primitives를 보아라.
마지막 단계는 장면을 닫는 것이다. 그런 다음 백버퍼를 프론트버퍼로 present한다.
이것은 다음 코드 조각에서 보여진다.
g_pd3dDevice->EndScene();
g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
백버퍼가 프론트버퍼에 present된 후에 클라이언트 윈도우는 세가지 다른 색깔을
가진 점을 가진 삼각형을 보여준다.
이 튜토리얼은 기하학 모양을 render하기 위하여 정점들을 사용하는 방법을
보여준다. '튜토리얼 3 : 행렬을 사용하기'는 행렬의 개념과 행렬을 사용하는 방법을
소개한다.
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 782번
제 목:[번역] DirectX Graphics #3
올린이:날래미 (조명근 ) 01/06/04 13:07 읽음: 64 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 114
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/10(화) 14:04
◎ 조회: 318 회
DirectX Graphics Tutorial 3 - Using Matrices
///////////////////////////////////////////////////////////////////////////////
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 3 : 행렬을 사용하기
//
// 번역 : 넷츠고 게임제작동호회 conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
///////////////////////////////////////////////////////////////////////////////
/
<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 3 : 행렬을 사용하기 >>>>>>>
<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>
이번 튜토리얼은 행렬의 개념을 소개하고 그것들을 어떻게 사용하는지를 보여줍니다.
정점 샘플 프로젝트는 삼각형을 그리기 위해서 2-D 정점들을 render했었습니다.
그러나 이번 튜토리얼에서는 3-D 정점들의 변환을 작업하게 될 것입니다. 행렬들은
또한 카메라들과 뷰포트들을 셋업하는데 사용됩니다. 행렬을 변환하는 작업에 관한
더 많은 정보를 원하시면 3-D Transformations 를 보십시요~
행렬 샘플 프로젝트는 지오메트리를 render하기 전에 3-D 삼각형을 render하기
위해서 사용되는 행렬 변환을 만들고 지정하기 위해 SetupMatrices 애플리케이션
정의 함수를 호출합니다. 전형적으로 세가지 유형의 변환이 3-D 장면에 지정됩니다.
전형적인 변환들 각각을 생성하는 단계는 아래에 목록화되어 있습니다.
* 단계 1 : 월드 변환 행렬을 정의하기
* 단계 2 : 뷰 변환 행렬을 정의하기
* 단계 3 : 투영 변환 행렬을 정의하기
행렬과 변환에 관한 더 많은 정보를 원하기면 Matrices를 보십시요~
3-D 변환에 대한 더 많은 정보를 원하시면 3-D Transformations를 보십이요~
(메모)
행렬 샘플 프로젝트는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut03_Matrices
에 있습니다.
생성된 이 세가지 변환 행렬의 순서는 장면에서 객체의 배치에 영향을 미치지
않습니다. 그러나 Direct3D 는 (1) 월드 (2) 뷰 (3) 투영 의 순서로 장면에 행렬을
적용합니다.
행렬 프로젝트의 샘플 코드는 정점 프로젝트의 샘플 코드와 거의 동일합니다. 행렬
사용하기 튜토리얼은 오직 행렬에 관한 부분에 초점을 맞추고 있고 Direct3D 초기화,
Microsoft Windows 메시지를 처리하는 것, rendering, 또는 종료를 다루고 있지
않습니다. 이 작업에 관한 정보를 원하시면, '튜토리얼 1 : 장치 생성하기'를
보십시요~
이 튜토리얼은 custom 정점들을 사용하고 display 지오메트리에 정점 버퍼를
사용합니다. custom 정점 유형을 선택하고 정점 버퍼를 구현하는 것에 대한 더 많은
정보를 원하시면 '튜토리얼 2 : 정점들을 rendering'을 보십시요~
**************************************************
******* 단계 1 : 월드 변환 행렬을 정의하기 *******
**************************************************
월드 변환 행렬은 지오메트리를 3-D 모델 공간에서 이동, 확대/축소, 회전하는
방법을 정의합니다.
다음 코드 조각은 Y-축으로 삼각형을 회전시킵니다. 그리고 그런다음 Microsoft
Direct3D 디바이스에 현재 월드 변환을 지정합니다.
D3DXMATRIX matWorld;
D3DXMatrixRotationY( &matWorld, timeGetTime()/150.0f );
g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
첫번째 단계는 D3DXMatrixRotationY 메소드를 호출함으로서 Y-축 둘레로 삼각형을
회전키시는 것입니다. 첫번째 인자는 동작의 결과값이 될 D3DXMATRIX 구조체의
포인터입니다. 두번째 인자는 라디안 값으로 회전 각도입니다.
다음 단계는 Direct3D 디바이스에 월드 변환을 지정하기 위해서
IDirect3DDevice8::SetTransform 를 호출합니다. SetTransform에 의해 받아들여지는
첫번째 인자는 Direct3D에게 지정할 변환을 전달합니다. 이 샘플은 월드 행렬이
지정되어야 함을 명시하기 위해서 D3DTS_WORLD 매크로를 사용합니다. 두번째 인자는
현재 변환으로 지정된 행렬을 위한 포인터입니다.
월드 변환에 대한 더 많은 정보를 얻기 원하시면 The World Transformation을
보십시요~
장면을 위한 월드 변환을 정의한 후에 뷰 변환 행렬을 준비할 수 있습니다. 또
정의된 변환의 순서는 치명적이지 않다는 것을 주목하십시요. 그러나 Direct3D 는
(1) 월드 (2) 뷰 (3) 투영의 순서로 장면에 행렬을 적용합니다.
뷰 변환 행렬을 정의하는 것은 '단계 2 : 뷰 변환 행렬을 정의하기'에서 설명되어
있습니다.
************************************************
******* 단계 2 : 뷰 변환 행렬을 정의하기 *******
************************************************
뷰 변환 행렬은 시각의 위치와 회전을 정의합니다. 뷰 행렬은 장면에서
카메라입니다.
다음 코드 조각은 뷰 변환 행렬을 생성하고 그런 다음 Micrsoft Direct3D 디바이스를
위한 현재 뷰 변환을 지정합니다.
D3DXMATRIX matView;
D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 3.0f,-5.0f ),
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
첫번째 단계는 D3DXMatrixLookAtLH를 호출함으로서 뷰 행렬을 정의하는 것입니다.
첫번째 인자는 동작의 결과값이 될 D3DXMATRIX 구조체의 포인터입니다. 두번째,
세번째, 네번째 인자는 시점, 시선, '위'방향 을 정의합니다. 여기서 눈은 Z-축을
따라 뒤로 5칸 그리고 위로 3칸을 지정되어 있으며 시선은 원점을 향하고 있으며
위는 Y-방향으로 정의되어 있습니다.
다음 단계는 Direct3D 디바이를 위한 뷰 행렬을 지정하기 위해
IDirect3DDevice8::SetTransform 를 호출하는 것입니다. SetTransform에 의해
받아들여지는 첫번째 인자는 Direct3D에게 지정될 변환을 전달합니다. 이 샘플은 뷰
행렬이 지정되도록 명시하기 위해서 D3DTS_VIEW 플래그를 사용합니다. 두번째 인자는
현재 변환으로 지정된 행렬를 위한 포인터입니다.
뷰 변환을 위한 더 많은 정보를 원하시면 The View Transformation 을 보십시요~
장면을 위한 뷰 변환을 정의한 후에 투영 변환 행렬을 준비할 수 있습니다. 또
정의된 변환의 순서는 치명적이지 않다는 것을 주목하십시요. 그러나 Direct3D 는
(1) 월드 (2) 뷰 (3) 투영의 순서로 장면에 행렬을 적용합니다.
투영 변환 행렬을 정의하는 것은 '단계 3 : 투영 변환 행렬을 정의하기'에서
설명되어 있습니다.
**************************************************
******* 단계 3 : 투영 변환 행렬을 정의하기 *******
**************************************************
투영 변환 행렬은 지오메트리가 어떻게 3-D 뷰 공간에서 2-D 뷰포트 공간으로
변환되는지를 정의합니다.
다음 코드 조각은 투영 변환 행렬을 생성하고 그런 다음 Microsoft Direct3D
디바이스를 위한 현재 투영을 시정합니다.
D3DXMATRIX matProj;
D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
첫번째 단계는 투영 행렬를 셋업하기 위하여 D3DXMatrixPerspectiveFovLH 를
호출하는 것입니다. 첫번째 인자는 동작의 결과값이 될 D3DXMATRIX 구조체의
포인터입니다. 두번째 인자는 시야를 정의합니다. 그것은 어떻게 거리에 따라 객체가
더 작게 보이는지를 전합니다. 전형적인 시야는 1/4 pi 입니다. 그리고 샘플에서 이
값을 사용합니다. 세번째 인자는 종횡비를 정의합니다. 샘플에서는 정형적인 종회비
1을 사용합니다. 네번째와 다섯번째 인자는 가까운 클리핑 면과 먼 클리핑 면을
정의합니다. 이것은 지오메트리가 더 이상 render되지 않아야 할 거리를 결정합니다.
행렬 샘플 프로젝트는 가까운 클리핑 면을 1로 설정하였고 먼 클리핑 면을 100으로
설정합니다.
다음 단계는 Direct3D 디바이스에 변환을 적용하기 위해서
IDirect3DDevice8::SetTransform 를 호출하는 것입니다. SetTransform에 의해
받아들여지는 첫번째 인자는 Direct3D에게 지정될 변환을 전달합니다. 이 샘플은 뷰
행렬이 지정되도록 명시하기 위해서 D3DTS_PROJECTION 플래그를 사용합니다. 두번째
인자는 현재 변환으로 지정된 행렬를 위한 포인터입니다.
투영 행렬을 위한 더 많은 정보를 위해서는 The Projection Transformation을
보십시요~
이 튜토리얼은 행렬을 사용하는 방법을 보여주었습니다. '단계 4 : 빛을 생성하고
사용하기'에서는 좀 더 현실성을 위해 장면에 빛을 추가하는 방법을 보여줍니다
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 783번
제 목:[번역] DirectX Graphics #4
올린이:날래미 (조명근 ) 01/06/04 13:08 읽음: 55 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 115
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/10(화) 16:13
◎ 조회: 235 회
DirectX Graphics Tutorial 4
////////////////////////////////////////////////////////////////////////////////
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 4 : 빛을 생성하고
사용하기
//
// 번역 : 넷츠고 게임제작동호회 conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
////////////////////////////////////////////////////////////////////////////////
<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 4 : 빛을 생성하고 사용하기 >>>>>>>
<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>
Microsoft Direct3D 빛은 3-D 객체에 좀 더 현실감을 더 합니다. 빛이 사용될
때
장면에서의 각각의 지오메트리 객체들은 위치와 사용되는 빛의 유형에
기반해서 빛을
받게 될 것입니다. 이번 튜토리얼에서의 샘플 코드는 빛과 재질의 논제를
소개한다.
이 튜토리얼은 재질과 빛을 생성하기 위해서 다음 단계를 가진다.
* 단계 1 : 장면 지오메트리를 초기화하기
* 단계 2 : 재질과 빛을 셋팅하기
(메모)
빛 샘플 프로젝트는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut04_Lights
에 있습니다.
빛 프로젝트에서의 샘플 코드는 행렬 프로젝트에서의 샘플 코드와 거의
동일합니다.
빛을 생성하고 사용하기 튜토리얼은 Direct3D 셋업, Microsoft Windows 메시지
처리,
rendering, 종료하기에 관한 것을 다루지 않고 빛을 생성하고 사용하기 위한
특정
코드에만 초점을 맞추고 있습니다. 앞의 작업에 대한 정보를 원하시면
'튜토리얼 1 :
장치 생성하기'를 보십시요~
이 튜토리얼은 custom 정점들을 사용하고 지오메트리를 나타내기 위하여 정점
버퍼를
사용합니다. custom 정점 유형을 선택하는 것과 정점 버퍼를 구현하는 것에
관한 더
많은 정보를 원하시면 '튜토리얼 2 : 정점들을 rendering하기'를 보십시요~
이 튜토리얼은 지오메트리를 변환하기 위하여 행렬들을 사용합니다. 행렬들과
변환들에 관하여 더 많은 정보를 원하시면 '튜토리얼 3 : 행렬들을
사용하기'를
보십시요~
*****************************************************
******* 단계 1 : 장면 지오메트리를 초기화하기 *******
*****************************************************
빛을 사용하는데 요구되는 한가지는 각 면이 법선을 가져야 하는 것입니다.
이것을
하기 위해서 빛 샘플 프로젝트는 다른 custom 정점 유형을 사용합니다. 이
새로운
custom 정점 형식은 3-D 위치와 면의 법선을 가집니다. 면의 법선은 빛
계산을
위해서 Microsoft Direct3D에 의해 내부적으로 사용됩니다.
struct CUSTOMVERTEX
{
D3DXVECTOR3 position; // 정점을 위한 3-D 위치
D3DXVECTOR3 normal; // 정점을 위한 면의 법선
};
// Custom FVF.
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL)
정확한 벡터 형식이 정의되었으므로, 빛 샘플 프로젝트는 원기둥을 생성하는
애플리케이션 정의 함수 InitGeometry를 호출합니다. 첫번째 단계는 다음 샘플
코드에서 보여진 것처럼 원기둥의 점을 저장하는 정점 버퍼를 생성하는 것입니다.
// 정점 버퍼를 생성한다.
if( FAILED( g_pd3dDevice->CreateVertexBuffer( 50*2*sizeof(CUSTOMVERTEX),
0 /* 처리법 */,
D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &g_pVB ) ) )
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) );
}
앞의 샘플 코드가 원기둥의 정점을 가진 정점 버퍼를 채운 후에 정점 버퍼는
rendering 할 준비가 되었습니다. 그러나 먼저, 원기둥을 rendering 하기 전에
장면을
위한 재질과 빛이 지정되어야만 합니다. 이것은 '단계 2 : 재질과 빛을
셋팅하기'에
설명되어 있습니다.
*********************************************
******* 단계 2 : 재질과 빛을 셋팅하기 *******
*********************************************
Microsoft Direct3D 에서 빛을 사용하기 위해서, 하나 이상의 빛을 생성해야만
합니다. 지오메트리 객체가 어떤 색을 반사할지를 결정하기 위하여 재질이
생성되고
재질은 지오메트리 객체를 render 하는데 사용됩니다. 장면을 render 하는 것
전에
빛 샘플 프로젝트는 한 재질과 한 방향 빛을 지정하기 위한 애플리케이션 정의
함수
SetupLights를 호출합니다. 이 함수는 재질과 빛을 생성하기 위하여 다음
단계를
작업합니다.
* 단계 2.1 : 재질을 생성하기
* 단계 2.2 : 빛을 생성하기
******************************************
******* 단계 2.1 : 재질을 생성하기 *******
******************************************
재질은 빛이 지오메트리 객체의 면에 부딪칠 때 반사될 색을 정의합니다. 다음
코드
조각은 노랑색으로 재질을 생성하기 위한 D3DMATERIAL8 구조체를 사용합니다.
D3DMATERIAL8 mtrl;
ZeroMemory( &mtrl, sizeof(D3DMATERIAL8) );
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 );
재질을 위한 diffuse 컬러와 ambient 컬러는 노랑색으로 지정되었습니다.
IDirect3DDevice8::SetMaterial 메소드를 호출하는 것은 장면을 render 하기
위해
사용된 Microsoft Direct3D 디바이스에 재질로 적용됩니다. SetMaterial이
받아들이는 오직 하나의 인자는 지정할 재질의 주소입니다. 이 호출이 불려진
후에
모든 프리미티브는 또 다른 재질을 명시하는 SetMaterial를 호출하기까지는 이
재질로 render될 것입니다.
재질이 장면에 적용되었으므로 다음 단계는 빛을 생성하는 것입니다. '단계
2.2 :
빛을 생성하기'에서 설명되었다.
****************************************
******* 단계 2.2 : 빛을 생성하기 *******
****************************************
Microsoft Direct3D에서 사용 가능한 세가지 종류의 빛이 있습니다. : 포인트
빛,
방향성 빛, 스포트라이트. 이 샘플 코드는 방향성 빛을 생성합니다. 그것은 한
방향으로 가는 빛입니다. 그리고 그것은 빛의 방향을 진동합니다.
다음 코드 조각은 방향성 빛을 생성하기 위하여 D3DLIGHT8 구조체를 사용합니다.
D3DXVECTOR3 vecDir;
D3DLIGHT8 light;
ZeroMemory( &light, sizeof(D3DLIGHT8) );
light.Type = D3DLIGHT_DIRECTIONAL;
다음 코드 조각은 휜색으로 이 빛을 위한 diffuse 컬러를 지정합니다.
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
다음 코드 조각은 원 주위로 빛의 방향을 회전합니다.
vecDir = D3DXVECTOR3(cosf(timeGetTime()/360.0f),
0.0f,
sinf(timeGetTime()/360.0f) );
D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecDir );
D3DXVec3Normalize 의 호출은 빛의 방향을 결정하기 위해 사용된 방향 벡터를
정규화합니다.
range는 빛이 영향을 미칠 거리를 Direct3D에게 전하기 위해 명시될 수
있습니다. 이
맴버는 방향성 빛에는 영향을 미치지 않습니다. 다음 코드 조각은 이 빛에
거리
1000을 할당하였습니다.
light.Range = 1000.0f;
다음 코드 조각은 IDirect3DDevice8::SetLight 를 호출함으로서 Direct3D
디바이스에
빛을 할당합니다.
g_pd3dDevice->SetLight( 0, &light );
SetLight 가 받아들이는 첫번째 인자는 이 빛이 할당받게 될 인덱스입니다.
만약
이미 빛이 그 위치에 존재한다면 새 빛에 의해서 겹쳐 써지게 될 것이라는
것을
주의하십시요. 두번째 인자는 빛을 정의하는 빛 구조체의 포인터입니다. 빛
샘플
프로젝트는 이 빛을 인덱스 0에 놓았습니다.
다음 코드 조작은 IDirect3DDevice8::LightEnable 를 호출함으로서 빛을 사용
할 수
있게 합니다.
g_pd3dDevice->LightEnable( 0, TRUE);
LightEnable 이 받아들이는 첫번째 인자는 허가할 빛의 인덱스입니다. 두번째
인자는
빛이 켜져 있는지( TRUE ) 아니면 커져 있는지( FALSE )를 전달하는 Boolean
값입니다. 위의 샘플 코드에서는 인덱스 0의 빛이 켜졌습니다.
다음 코드 조각은 IDirect3DDevice8::SetRenderState 를 호출함으로서
Direct3D에게
빛을 render 하도록 전달합니다.
g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
SetRenderState 가 받아들이는 첫번째 두 인자는 수정할 장치 상태 값이
무엇인지
그리고 그것에 지정될 값이 무엇인지 입니다. 이 코드 샘플은 빛의
rendering을
가능하도록하는 효과를 가지도록 D3DRS_LIGHTING 장치 값을 TRUE 로 지정합니다.
이 코드 샘플의 마지막 단계는 SetRenderState 를 다시 호출함으로서 ambient
빛을
켜는 것입니다.
g_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x00202020 );
앞의 코드 조각은 D3DRS_AMBIENT 장치 값을 회색빛(0x00202020)로 지정하였다.
ambient 빛은 주어진 색에 의해서 모든 객체들을 밝힐 것이다.
빛에 관한 더 많은 정보를 원하시면 Mathemtics of Direct3D Lighting을 보십시요~
이 튜토리얼은 빛과 재질을 사용하는 방법을 보여줍니다. '튜토리얼 5 :
텍스춰 맵을
사용하기'는 면에 텍스춰를 더하는 방법을 보여줍니다.
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 784번
제 목:[번역] DirectX Graphics #5
올린이:날래미 (조명근 ) 01/06/04 13:08 읽음: 58 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 116
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/10(화) 18:21
◎ 조회: 254 회
DirectX Graphics Tutorial 5
--------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 5 : 텍스춰 맵을 사용하기
//
// 번역 : 넷츠고 게임제작동호회 conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
////////////////////////////////////////////////////////////////////////////////
<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 5 : 빛을 생성하고 사용하기 >>>>>>>
<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>
빛들과 재질이 장면에 굉장한 현실감있는 처리를 추가해 주는 한편 면에
텍스춰를
추가하는 것보다 더 현실감을 더하는 것은 없습니다. 텍스춰는 면 위에 포장된
벽지로서 생각될 수 있습니다. 정육면체가 실제로 나무로 만들어진 것처럼
보이게
하기 위해서 정육면체 위에 나무 텍스춰를 놓을 수도 있습니다. 텍스춰 샘플
프로젝트는 '튜토리얼 4 : 빛을 생성하고 사용하기'에서 만들었던 원기둥에
바나나
껍질 텍스춰를 추가합니다. 이 튜토리얼은 텍스춰를 읽어들이는 방법,
정점들을
지정, 텍스춰를 가진 display 객체를 다룹니다.
이 튜토리얼은 다음 단계를 사용해서 텍스춰를 구현합니다.
* 단계 1 : Custom 정점 형식 정의하기
* 단계 2 : 화면 지오메트리 초기화하기
* 단계 3 : 장면을 render 하기
(메모)
텍스춰 샘플 프로젝트는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut05_Textures
에 있습니다.
텍스춰 프로젝트의 샘플 코드는 텍스춰 샘플 프로젝트가 재질이나 빛을
생성하지
않는다는 것을 제외하면 빛 프로젝트의 샘플 코드와 거의 동일합니다. 텍스춰
맵
사용하기는 텍스춰에 해당하는 코드에만 초점이 맞추어져 있습니다. Microsoft
Direct3D를 초기화하기, Microsoft Windows 메시지 처리하기, render 하기,
종료
하기를 다루지 않습니다. 이 작업에 대한 정보를 원하시면 '튜토리얼 1 : 장치
생성하기'를 보십시요~
이 튜토리얼은 custom 정점들을 사용하고 지오메트리를 나타내기 위해서 정점
버퍼를
사용합니다. custom 정점 형식을 선택하고 정점 버퍼를 구현하는 데에 관한 더
많은
정보를 얻기 원하시면 '튜토리얼 2 : 정점들을 render 하기'를 보십시요~
이 튜토리얼은 지오메트리를 변환하는 행렬을 이용합니다. 행렬들과 변환들에
관한
더 많은 정보를 원하시면 '튜토리얼 3 : 행렬을 사용하기'를 보십시요~
**************************************************
******* 단계 1 : Custom 정점 형식 정의하기 *******
**************************************************
텍스춰를 사용하기 전에 텍스춰 자표계가 포함되어 있는 custom 정점 형식이
사용되어야만 합니다. 텍스춰 좌표계는 프리미티브에서 각 벡터를 위한
텍스춰가
위치되어야 하는 곳을 Microsoft Direct3D 에게 전달합니다. 텍스춰 좌표계는
0.0에서 1.0까지가 범위입니다. 그래서 (0.0, 0.0)은 텍스춰의 왼쪽-위편을
표현하며
(1.0, 1.0)은 텍스춰의 오른쪽-아래편을 나타냅니다.
다음 샘플 코드는 어떻게 텍스춰 샘플 프로젝트가 텍스춰 좌표계를 포함하는
custom
정점 형식을 지정하는지를 보여줍니다.
struct CUSTOMVERTEX
{
D3DXVECTOR3 position; // 위치
D3DCOLOR color; // 컬러
FLOAT tu, tv; // 텍스춰 좌표
};
// custom FVF custom 정점 구조체를 설명합니다.
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1)
텍스춰 좌표계에 대한 더 많은 정보를 원하시면 Texture Coordinates 를 보십시요~
custom 정점 형식이 정의되었으므로, 다음 단계는 '단계 2 : 화면
지오메트리를
초기화하기'에서 설명된 것처럼 텍스춰를 불러들이는 것과 원기둥을 만드는
것입니다.
*****************************************************
******* 단계 2 : 화면 지오메트리를 초기화하기 *******
*****************************************************
render 하기 전에 텍스춰 샘플 프로젝트는 텍스춰를 생성하고 원기둥을 위한
지오메트리를 초기화하는 애플리케이션 정의 함수인 InitGeometry를 호출합니다.
텍스춰들이 파일기반 이미지들로부터 생성됩니다. 다음 코드 조각은 원기둥의
면을
덮는데 사용될 Banana.bmp 로부터 텍스춰를 생성하기 위하여
D3DXCreateTextureFromFile 를 사용합니다.
if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice, "Banana.bmp",
&g_pTexture ) ) )
return E_FAIL;
D3DXCreateTextureFromFile가 받아들이는 첫번째 인자는 텍스춰를
render하는데
사용될 Microsoft Direct3D 디바이스의 포인터입니다. 두번째 인자는 텍스춰를
생성하기 위한 파일이름을 명시하는 ANSI 문자열의 포인터입니다. 아 샘플은
그
파일로부터 이미지를 불러오기 위하여 Banana.bmp를 지정했습니다. 세번째
인자는
텍스춰 객체의 포인터 주소입니다.
바나나 텍스춰가 불려지고 사용할 준비가 되었을 때 다음 단계는 원기둥을
만드는
것입니다. 다음 코드 샘플은 원기둥을 가지는 정점 버퍼를 채우는 것입니다.
각
점들이 텍스춰 좌표(tu, tv)를 가지고 있음을 주목하십시요.
for( DWORD i=0; i<50; i++ )
{
FLOAT theta = (2*D3DX_PI*i)/(50-1);
pVertices[2*i+0].position = D3DXVECTOR3( sinf(theta),-1.0, cosf(theta) );
pVertices[2*i+0].color = 0xffffffff;
pVertices[2*i+0].tu = ((FLOAT)i)/(50-1);
pVertices[2*i+0].tv = 1.0f;
pVertices[2*i+1].position = D3DXVECTOR3( sinf(theta), 1.0, cosf(theta) );
pVertices[2*i+1].color = 0xff808080;
pVertices[2*i+1].tu = ((FLOAT)i)/(50-1);
pVertices[2*i+1].tv = 0.0f;
}
각 점은 위치, 색, 그리고 텍스춰 좌표들을 포함합니다. 위의 코드 샘플은 각
점을
위한 텍스춰 좌표를 지정합니다. 그 결과 텍스춰는 원기둥 주위를 부드럽게
감쌀
것입니다.
텍스춰가 불려지고 정점 버퍼가 render 할 준비가 되었으므로, '단계 3 :
장면을
render 하기'에서 설명된 것처럼 display를 render할 시간이 되었습니다.
*******************************************
******* 단계 3 : 장면을 render 하기 *******
*******************************************
장면 지오메트리가 초기화된 후, 장면을 render할 때가 되었습니다. 텍스춰를
가진
객체를 render 하기 위하여, 그 텍스춰가 현재 텍스춰들 중의 하나로서
지정되어야만
합니다. 다음 단계는 텍스춰 무대 상태 값을 지정하는 것입니다. 텍스춰 무대
상태는
하나의 텍스춰나 텍스춰들이 어떤 동작으로 render 될 것인가를 정의하는 것을
가능하게 합니다. 예를 들어, 다중 텍스춰를 함수께 브렌딩할 수 있습니다.
텍스춰 샘플 프로젝트는 사용할 텍스춰를 지정함으로서 시작합니다. 다음 코드
조각은 Microsoft Direct3D 디바이스가 IDirect3DDevice8::SetTexture 를
가지고
render에 사용 할 택스춰를 지정합니다.
g_pd3dDevice->SetTexture( 0, g_pTexture );
SetTexture가 받아들이는 첫번째 인자는 텍스춰를 지정하는 무대 ID 입니다.
디바이스는 텍스춰를 8개까지 가질 수 있습니다. 그래서 여기서 최대값은
7입니다.
텍스춰 샘플 프로젝트는 오직 한 텍스춰만 가집니다. 그리고 그것을 무대 0에
놓았습니다. 두번째 인자는 텍스춰 객체의 포인터입니다. 텍스춰 샘플
프로젝트는
애플리케이션 정의 함수인 InitGeometry에서 만들어진 텍스춰 객체를 사용합니다.
다음 코드 샘플은 IDirect3DDevice8::SetTextureStageState 메소드를
호출함으로서
텍스춰 무대 상태 값을 설정합니다.
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
SetTextureStageState가 받아들이는 첫번째 인자는 설정될 상태값을 위한 무대
인덱스입니다. 이 코드 샘플은 무대 0인 텍스춰를 위한 값을 변화시키고
있습니다.
그래서 여기서 0을 놓습니다. 다음 인자는 설정될 텍스춰 상태입니다. 모든
유효한
텍스춰 상태의 리스트와 그들의 의미를 보기 원하시면
D3DTEXTURESTAGESTATETYPE 를
보십시요~ 다음 인자는 텍스춰 상태를 설정할 값입니다. 여기에 놓이는 값은
당신이
수정하고 있는 텍스춰 무대 상태 값에 기반합니다.
각 텍스춰 무대 상태를 위한 원하는 값을 설정한 후에 원기둥은 render 될 수
있고
텍스춰는 면에 더해질 것입니다.
텍스춰 좌표를 사용하는 또 다른 방법은 그들을 자동적으로 발생시켜지게 하는
것
입니다. 이것은 텍스춰 좌표 인덱스( TCI )를 사용하으로서 행해집니다. TCI는
(x,
y, z) TCI 좌표를 (tu, tv) 텍스춰 좌표로 변환하기 위하여 텍스춰 행렬을
사용합니다. 텍스춰 샘플 프로젝트에서는 카메라 공간에서 정점의 위치는
텍스춰
좌표를 발생하는데 사용됩니다.
첫번째 단계는 다음 코드 조각에서 보여주는 것처럼 변환을 위해 사용될
행렬을
생성하는 것입니다.
D3DXMATRIX 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;
행렬을 생성한 후에 다음 코드 조각에서 보여진 것처럼
IDirect3DDevice8::SetTransform 를 호출함으로서 설정되어야만 합니다.
g_pd3dDevice->SetTransform( D3DTS_TEXTURE0, &mat );
D3DTS_TEXTURE0 플래그는 Direct3D에게 텍스춰 무대 0에 위치한 텍스춰에게
변환을
적용할 것을 전달합니다. 이 샘플이 작업하는 다음 단계는 원하는 호과를 얻기
위하여 더 많은 텍스춰 무대 상태 값을 설정하는 것입니다. 그것은 다음 코드
조각에서 행해집니다.
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS,
D3DTTFF_COUNT2 );
g_pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX,
D3DTSS_TCI_CAMERASPACEPOSITION );
텍스춰 좌표계가 설정되었습니다. 그리고 지금 장면이 render 될 준비가
되었습니다.
좌표계가 원기둥을 위해 자동적으로 생성된 것을 주목하라. 이것은 특별한
설정은
지오메트리 모양들이 render한 후에 render한 화면위에 놓여지게 되는 텍스춰
효과를
가집니다.
텍스춰들에 관한 더 많은 정보를 원하시면 Textures 를 보십시요.
이 튜토리얼은 면에 텍스춰를 사용하는 방법을 보여줍니다. '튜토리얼 6 :
메쉬들을
사용하기'는 메쉬들을 가진 복잡한 지오메트리 모양들을 사용하는 방법들을
보여줍니다
『시지프스(Cezips) C/C++프로그래밍-C/C++ 강좌 (go CEZIPS)』 785번
제 목:[번역] DirectX Graphics #6 <LAST>
올린이:날래미 (조명근 ) 01/06/04 13:09 읽음:116 관련자료 없음
-----------------------------------------------------------------------------
◎ No, 117
◎ 이름:conaman (conaman@netsgo.com)
◎ 홈페이지:http://myhome.netsgo.com/conaman
◎ 2001/4/11(수) 19:27
◎ 조회: 452 회
DirectX Graphics Tutorial 6
////////////////////////////////////////////////////////////////////////////////
// 제목 : DirectX Graphics C++ Tutorial - 튜토리얼 6 : 메쉬들을 사용하기
//
// 번역 : 넷츠고 게임제작동호회 conaman ( conaman@netsgo.com )
//
// 저작권 : 문서의 배포에는 제한이 없습니다만 수정하실 때에는 연락주십시요~
////////////////////////////////////////////////////////////////////////////////
<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>
<<<<<<< 튜토리얼 6 : 메쉬들을 사용하기 >>>>>>>
<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>
복잡한 지오메트리는 대개 3-D 모델링 소프트웨어를 사용하여 모델링되고
파일로
저장됩니다. 이 예제는 .x 파일 형식입니다. Microsoft Direct3D는 이
파일들로부터
객체를 불러오기 위해서 메쉬들을 사용합니다. 메쉬들은 다소 복잡하지만
D3DX는 더
쉽게 메쉬들을 사용하게 하는 함수를 포함하고 있습니다. 메쉬 샘플
프로젝트는
메쉬에 대한 주제를 소개하고 있고 메시를 load, render, unload하는 방법을
보여줍니다.
이 튜토리얼은 다음 단계를 사용해서 메쉬를 load, render, unload하는 방법을
보여줍니다.
* 단계 1 : 메쉬 객체를 load 하기
* 단계 2 : 메쉬 객체를 render 하기
* 단계 3 : 메쉬 객체를 unload 하기
(메모)
메쉬 샘플 프로젝트의 경로는
(SDK Root)\Samples\Multimedia\Direct3D\Tutorials\Tut06_Meshes
입니다.
메쉬 프로젝트의 샘플 코드는 재질과 빛을 생성하지 않는 것을 제외하고는 빛
프로젝트와 거의 동일합니다.. 메쉬 튜토리얼은 메쉬들에 대한 부분만을
초점하고
있습니다. Direct3D 셋업, Microsoft Windows 메시지, render 하기,
종료하기를
다루지 않습니다. 이런 작업들에 관한 정보를 얻기 원하시면 '튜토리얼 1 :
장치
생성하기'를 보십시요~
이 튜토리얼은 지오메트리를 나타내기 위해 custom 정점들을 사용하고 정점
버퍼를
사용합니다. custom 정점 형식을 선택하고 정점 버퍼를 구현하는 것에 관해
더
정보를 얻기 원하시면 '튜토리얼 2 : 정점들을 render 하기'를 보십시요~
이 튜토리얼은 지오메트리를 변환하기 위하여 행렬들을 이용합니다. 행렬과
변환에
관해 더 정보를 얻기 원하시면 '튜토리얼 3 : 행렬들을 사용하기'를 보십시요~
이 튜토리얼은 메쉬의 면을 덮기 위해 텍스춰를 사용합니다. 텍스춰를
불러오고
사용하는 것에 대해 자세히 알기 원하시면 '튜토리얼 5 : 텍스춰 맵
사용하기'를
보십시요~
**********************************************
******* 단계 1 : 메쉬 객체를 load 하기 *******
**********************************************
Microsoft Direct3D 애플리케이션은 먼저 메쉬를 사용하기 전에 메쉬를
불러와야만
합니다. 메쉬 샘플 프로젝트는 요구되는 Direct3D 객체들을 불러온 후에
애플리케이션 정의 함수인 InitGeometry를 호출함으로서 호랑이 메쉬를
불러옵니다.
메쉬는 사용하게 될 모든 재질과 텍스춰를 저장할 재질 버퍼를 필요로
합니다.그
함수는 다음 코드 조각에서 보여진 것처럼 재질 버퍼를 선언함으로서 시작됩니다.
LPD3DXBUFFER pD3DXMtrlBuffer;
다음 코드 조각은 메쉬를 불러오기 위하여 D3DXLoadMeshFromX 메소드를
사용합니다.
// 특정 파일로 부터 메쉬를 불러온다.
if( FAILED( D3DXLoadMeshFromX( "tiger.x", D3DXMESH_SYSTEMMEM,
g_pd3dDevice, NULL,
&pD3DXMtrlBuffer, &g_dwNumMaterials,
&g_pMesh ) ) )
return E_FAIL;
D3DXLoadMeshFromX가 받아들이는 첫번째 인자는 불러올 Microsoft DirectX
파일의
이름을 전달하는 문자열의 주소입니다. 이 샘플은 Tiger.x로부터 호랑이
메쉬를
불러옵니다.
두번째 인자는 Direct3D 에게 메쉬를 생성하는 방법을 전달합니다. 샘플은
D3DXMESH_SYSTEMMEM플래그를 사용하는데 그것은 D3DXMESH_VB_SYSTEMMEM와
D3DXMESH_IB_SYSTEMMEM를 모두 명시하는 것과 동일합니다. 이들 플래그 둘 다
Direct3D에 시스템 메모리에 메쉬를 위한 인덱스 버퍼와 정점 버퍼를 놓으라고
전달합니다.
세번째 인자는 메쉬를 render 하는데 사용될 Direct3D 장치의 포인터입니다.
네번째 인자는 ID3DXBuffer 객체의 포인터입니다. 이 객체는 각 face의
이웃들에
관한 정보로 채워질 것입니다. 이 정보는 이 샘플에서는 요구되지 않습니다.
그래서
인자는 NULL로 지정됩니다.
다섯번째 인자도 또한 ID3DXBuffer 객체의 포인터를 취합니다. 이 메소드는
종료한
후에 이 객체는 메쉬에 대한 D3DXMATERIAL 구조체로 채워질 것입니다.
여섯번째 인자는 메소드가 리턴된 후에 ppMaterials 배열로 위치할
D3DXMATERIAL
구조체의 개수를 위한 포인터입니다.
일곱번째 인자는 불러온 메쉬를 나타내는 메쉬 객체의 포인터의 주소입니다.
메쉬 객체와 재질 정보를 불러온 후에 재질 버퍼로부터 재질 속성과 텍스춰
이름을
추출하는 것이 필요합니다.
메쉬 샘플 프로젝트는 먼저 재질 버퍼의 포인터를 얻음으로서 이 것을
수행합니다.
다음 코드 조각은 이 포인터를 얻기 위해 ID3DXBuffer::GetBufferPointer
메소드를
사용합니다.
D3DXMATERIAL*
d3dxMaterials=(D3DXMATERIAL*)pD3DXMtrlBuffer->GetBufferPointer();
다음 코드 조각은 메쉬의 총 재질수에 기반한 새로운 메쉬와 텍스춰 객체를
생성합니다.
g_pMeshMaterials = new D3DMATERIAL8[g_dwNumMaterials];
g_pMeshTextures = new LPDIRECT3DTEXTURE8[g_dwNumMaterials];
메쉬안에 각각의 재질을 위해 다음 단계가 발생한다.
첫번째 단계는 다음 코드 조각에서 보이는 것처럼 재질을 복사하는 것입니다.
g_pMeshMaterials[i] = d3dxMaterials[i].MatD3D;
두번째 단계는 다음 코드 조각에서 보이는 것처럼 재질을 위해 ambient 컬러를
지정하는 것입니다.
g_pMeshMaterials[i].Ambient = g_pMeshMaterials[i].Diffuse;
마지막 단계는 다음 코드 조각에서 보이는 것처럼 재질을 위해 텍스춰를
생성하는
것입니다.
// 텍스춰를 생성한다.
if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice,
d3dxMaterials[i].pTextureFilename,
&g_pMeshTextures[i] ) ) )
g_pMeshTextures[i] = NULL;
}
각 재질을 불러온 후에 재질 버퍼를 종료하고 IUnknown::Release 를
호출함으로서
해제할 필요가 있습니다.
pD3DXMtrlBuffer->Release();
부합하는 재질과 텍스춰를 가진 메쉬가 불려졌습니다. '단계 2 : 메쉬 객체를
render
하기'에서 설명된 것처럼 메쉬는 display에 render될 준비가 되었습니다.
************************************************
******* 단계 2 : 메쉬 객체를 render 하기 *******
************************************************
단계 1에서 메쉬가 불려졌고 이제 render할 준비가 되었습니다. 그것은 메쉬를
위해
불려진 각 재질을 위해 부분집합으로 나뉘어져 있습니다. 각 부분집합을
render 하기
위하여 메쉬는 루프안에서 render됩니다. 루프안에서의 첫번째 단계는 다음
코드
조각에 보이는 것처럼 부분집합을 위한 재질을 지정하는 것입니다.
g_pd3dDevice->SetMaterial( &g_pMeshMaterials[i] );
루프 안에서의 두번째 단계는 다음 코드에서 보이는 것처럼 부분집합을 위한
텍스춰를 지정하는 것입니다.
g_pd3dDevice->SetTexture( 0, g_pMeshTextures[i] );
재질과 텍스춰를 지정한 후에 부분집합은 다음 코드 조각에서 보이는 것처럼
ID3DXBaseMesh::DrawSubset 메소드로 그려집니다.
g_pMesh->DrawSubset( i );
DrawSubset 메소드는 그리기 위한 메쉬의 부분집합을 명시하는 DWORD 를
취합니다.
이 샘플은 루프가 돌아가는 각 시간마다 증가되는 값을 사용합니다.
메쉬를 사용한 후에는 '단계 3 : 메쉬 객체를 unload 하기'에서 설명된 것처럼
메모리에서 메쉬를 적당하게 제가하는 것이 중요합니다.
************************************************
******* 단계 3 : 메쉬 객체를 unload 하기 *******
************************************************
어떤 Microsoft DirectX 프로그램이 끝이 난 후에 사용한 어떤 DirectX 객체도
해제할 필요가 있으며 또한 그들의 포인터를 무효화시킬 필요가 있습니다. 이
샘플에서 사용된 메쉬 객체도 또한 해제되는 것이 필요합니다. WM_DESTORY
메시지를
받았을 때에 이 메쉬 샘플 프로젝트는 이것을 처리하기 위해 애플리케이션
정의
함수인 Cleanup 을 호출합니다.
다음 코드 조각은 재질 목록을 삭제합니다.
if( g_pMeshMaterials )
delete[] g_pMeshMaterials;
다음 코드 조각은 불려진
