🙇세상의 중심🌐

less..

 

요즘 국내에서도 소프트웨어 수출의 바람이 일고 있다. 소프트웨어 중에

서 게임 소프트웨어만큼 수출이 용이한 분야도 없을 것이다.

특히 네트워크를 통한 온라인 게임이 각광받고 있는데 이 특집이 그런 분

야에 관심있는 독자들에게 시작할 수 있는 토대가 되었으면 하는 바램이다.

여기에서는 예제 프로그램 제작에 비주얼 C++ 5.0을 사용할 것이다. MFC

를 사용해 프로그래밍하지는 않을 것이고 SDK를 사용해 API로 프로그래밍

을 할 것이다. MFC를 이용할 경우에는 다이렉트X 자체보다는 MFC에 대한

지식이 필요해 설명하고자 하는 초점이 흐려질 수 있기 때문이다.

다이렉트X의 소개

다이렉트X란 ?

얼마 전 다이렉트X 6.0이 발표되었다. 필자는 다이렉트X 5.0에 기반하여

원고를 작성하였는데 사실 다이렉트 드로우나 다이렉트 사운드 레벨의 프

로그래밍에서 5.0과 6.0은 기능 상에 있어 큰 차이가 없다. 먼저 다이렉트X

가 무엇인지부터 살펴보도록 하겠다. 한마디로 다이렉트X를 소개하면 ‘다

이렉트X는 마이크로소프트가 발표한 멀티미디어용 라이브러리’라고 하면

될 것이다. 다이렉트X의 원래 등장 목적은 MS 도스 기반으로 형성되어있던

게임시장을 윈도 기반으로 돌릴 수 있는 바탕을 마련해주자는 것이었다. 모

든 프로그램이 MS 도스에서 윈도로 넘어간 시점에서도 게임만은 MS 도스

기반으로 제작될 수밖에 없던 적이 있었다. 이는 윈도에서는 빠른 그래픽

출력이 불가능했기 때문이었다. 물론 MS 도스상의 게임 제작에도 커다란

난점은 있었다. 게임 제작에 사용할 수 있는 표준 인터페이스가 없었기 때

문에 그래픽 보드나 사운드 카드, 입력 장치마다 별도의 드라이버를 직접

만들어야 했다. 그렇기 때문에 새로운 하드웨어가 발표되면 해야할 일이

많았다.

반면에 윈도는 GDI(Graphic Device Interface)와 MCI(Mul timedia

Control Interface)라는 표준 인터페이스를 통해 화면과 사운드 등을 제어

할 수 있도록 해주기 때문에 실제 사용되는 하드웨어가 무엇인지 개발자가

신경쓰지 않아도 되도록 해주었지만 게임의 속성상 가장 중요한 속도가 느

려지는 단점이 존재하였다. 한 번 상상해보기 바란다. 아무리 화려한 사운

드에 네트워크 기능까지 지원된다한들 화면 속도가 굼벵이 기어가듯 한다

면 누구도 선뜻 사용하려 하지 않을 것이다.

윈도 환경의 이런 단점을 극복할 수 있는 API를 게임 개발자들에게 제공하

자는 목적으로 만들어진 것이 바로 다이렉트X이다. 다이렉트X는 속도 향상

과 기반 하드웨어에 상관없는 단일 인터페이스를 통한 프로그래밍을 제공해

주는, 두 마리의 토끼를 잡자는 목적을 갖고 있다.

사실 다이렉트X 이전에도 WinG라 하여 비슷한 목적의 API가 발표된 적이 있

었으나 크게 성공을 거두지는 못하였고 그 뒤에 게임 SDK라는 이름으로 다

이렉트X가 발표되었다가 최종적으로 다이렉트X라는 이름으로 변경되었다.

다이렉트라는 말이 의미하는 것은 하드웨어를 우회하여 접근하는 것이 아

니라 직접 접근할 수 있도록 해줌으로써 빠른 속도를 제공해준다는 것이

다. 처음에 다이렉트X는 게임 개발만을 위한 API로 개발되었지만 지금은 멀

티미디어 관련 모든 응용에 사용할 수 있는 표준 API로 발전한 상태이다.

독자 여러분도 다이렉트X를 게임 개발만에 사용할 수 있다고 한정짓지 말

기 바란다. 다이렉트X가 지향하는 목표는 다음과 같다.

오락, 멀티미디어, 인터넷을 하나로

다이렉트X를 통해 게임과 멀티미디어 서비스 개발자는 속도상의 장점을 유

지하면서 디바이스 독립성이라는 장점을 유지하게 되었다. 다이렉트X가 주

는 멀티미디어 기능은 웹 상에도 적용 가능한 부분이 무궁무진하기 때문

에 애초의 게임 제작용 라이브러리라는 이미지에서 범용 멀티미디어 서비

스 라이브러리라는 보다 광범위한 범주에서 사용될 것이다.

하드웨어 발전의 가속화

다이렉트X는 보드에 이용 가능한 기능이 있을 경우 이를 소프트웨어적으로

처리하기 보다는 하드웨어적으로 처리한다. 또한 그래픽/사운드 보드나

그래픽 가속기를 만드는 하드웨어 업체(IHV : Independent Hardware

Vendors)의 의견을 적극 수렴하여 다이렉트X 하드웨어 개발 가이드라인을

만들기 때문에 하드웨어 기술과 동반 발전하는 상승 효과를 낳고 있다. 다

이렉트X는 하드웨어 기능이 있을 경우 이를 이용하고 없을 경우에만 소프

트웨어적으로 애뮬레이션한다.

개발자, 하드웨어 업체, 사용자 모두의 기대 충족

결과적으로 다이렉트X는 이와 관련된 모든 개발자들에게는 개발의 용이함

을 제공해주고 하드웨어 업체에게는 기술 발전과 더불어 더 많은 매출을

가능케 해주었으며 사용자들은 만족할 만한 수준의 프로그램을 사용할 수

있는 결과를 가져오게 되었다.

다이렉트X의 구성

현재 다이렉트X는 처음 발표할 때에 비해 굉장히 그 구성이 비대해졌다.

크게 상위 레벨의 서비스를 제공해주는 다이렉트X 미디어(DirectX Media)

와 하위 레벨의 기반을 제공해주는 다이렉트X 파운데이션(DirectX

Foundation)으로 구성된다.

먼저 기반이 되는 다이렉트X 파운데이션을 살펴보자. 이를 구성하는 요소

들로는 다이렉트 드로우, 다이렉트 인풋, 다이렉트 사운드, 다이렉트 3D

(Immediate mode), 다이렉트 셋업 등을 들 수 있다. 필자가 이번 특집에

서 다루고자 하는 부분은 바로 다이렉트X 파운데이션의 극히 일부에 해당한

다. 그만큼 다이렉트X는 방대해졌다. 다이렉트X 파운데이션을 구성하는 요

소들의 역할에 대해 간단히 요약하면 표 1과 같다.

다이렉트X 파운데이션을 기반으로 하는 다이렉트X 미디어에는 다이렉트 쇼

우, 다이렉트 애니메이션, 다이렉트 3D(Retained Mode), 다이렉트 플레이

등이 포함된다. VRML에 대한 지원 역시 다이렉트X 미디어에 포함된다. 다

이렉트X 미디어를 구성하는 요소들의 역할에 대해 간단히 요약하면 표 2와

같다.

그림 1 : 다이렉트X의 구성

===============================================================

다이렉트 드로우(DirectDraw) 빠른 속도의 그래픽 출력을 담당하는 객체

--------------------------------------------------------------

다이렉트 사운드(DirectSound) 3D까지의 사운드 출력과 사운드 녹음을

담당하는 객체

---------------------------------------------------------------

다이렉트 인풋(Direct Input) 마우스, 키보드, 조이스틱등의

장치로부터의 입력을 담당하는 객체

---------------------------------------------------------------

다이렉트 3D(Immediate Mode) 최적화된 3차원 그래픽 출력 엔진

---------------------------------------------------------------

다이렉트 셋업(Direct Setup) 다이렉트X 관련 프로그램의 설치

프로그램의 생성을 담당하는 객체

===============================================================

표 1 : 다이렉트X 파운데이션을 구성하는 요소들의 역할

그림 2 : 다이렉트X 파운데이션의 구조

다이렉트X는 윈도 98이나 윈도 NT 5.0에서는 운영체계의 일부로 설치된다.

하지만 윈도 95와 NT 4.0에서는 별도로 설치해주어야 한다. 만일 독자 여러

분의 PC에 윈도용 게임을 설치한 적이 있다면 다이렉트X가 설치되어 있을

것이다(게임을 설치할 때 같이 설치되었을 것이다). 다이렉트X가 설치되

지 않았거나 이전 버전의 다이렉트X가 설치되어 있다면 웹사이트

(http://www.microsoft.com/directx)나 국내 통신망을 통해 다운로드받을

수 있을 것이다. 사실 다이렉트X의 설치는 꽤 까다로운 편인데 다이렉트 셋

업을 이용하면 쉽게 설치 프로그램을 만들 수 있다.

===============================================================

다이렉트쇼우 파일이나 인터넷상의 서버로부터의 동영상등의

(DirectShow) 플레이나 녹화를 담당하는 객체

---------------------------------------------------------------

다이렉트 애니메이션 DHTML과 통합되어 웹 페이지상에서 애니메이션

을 (DirectAnimation) 제공해주는 객체

---------------------------------------------------------------

다이렉트3D 3차원 환경에서의 애니메이션을 쉽게 해주는 객체(Retained

Mode 다이렉트 플레이 네트워크나 모뎀을 통한 멀티 사용자 게임을 쉽게

(DirectPlay) 해주는 객체

===============================================================

표 2 : 다이렉트X 미디어를 구성하는 요소들의 역할

그림 3 : 다이렉트X 미디어의 구조

다이렉트X와 COM

잘 알고 있듯이 다이렉트 X 구성 요소들은 모두 COM 인터페이스를 사용하

고 있다. 이 COM은 마이크로소프트에서 제시한 바이너리 표준 인터페이스

스펙으로서 뛰어난 확장성을 제공하는 기반이 되고 있다. 결국 다이렉트 X

를 사용하려면 COM에 대한 지식이 필요하다. 그렇다고 아주 어려운 것

은 아니니까 걱정할 필요는 없다. COM 프로그래밍에 두 가지 종류가 있

다. 하나는 COM 객체를 만드는 프로그래밍이고 나머지 하나는 남이 만들

어 놓은 COM 객체를 사용하는 프로그래밍이다. 전자를 COM 서버 프로그래

밍이라고 하고 후자를 COM 클라이언트 프로그래밍이라고 한다. 전자는 상

당히 까다롭고 어렵고 힘들고 따분하지만 후자는 그리 복잡하거나 어렵지

않다. 다이렉트X의 구성 요소들은 COM 객체로 구성되어 있다. 그 이야기

는 이미 만들어져 있는 COM 객체이기 때문에 우리가 프로그램을 제작할 때

필요하다면 갖다 쓰기만 하면 된다는 것이다. 즉, 다이렉트X 프로그래밍

은 COM 클라이언트 프로그래밍이 되기 때문에 COM에 대한 많은 지식을 필

요로 하지 않는다.

원래 COM 프로그래밍에서 어떤 COM 객체가 제공해주는 인터페이스를 이용

하려면 그 객체의 CLSID나 ProgID를 알아야한다. 그 다음으로 그것의 클래

스팩토리(IClassFactory) 인터페이스를 얻어서 객체를 하나 생성하면서

지정한 인터페이스에 대한 포인터를 얻을 수 있다. 모든 COM 인터

페이스는 IUnknown으로 계승되므로 QueryInteface, AddRef, Release 등의

메소드 호출을 통해 다른 관련 인터페이스에 대한 포인터도 얻을 수 있고

객체의 메모리에서의 제거도 해줄 수 있다. COM 프로그래밍에 대한 지식이

없는 사람이 위의 말을 읽어보면 무슨 소리인지 이해가 안 갈 것이다. 다이

렉트X 객체들이 제공해주는 기능들을 이용할 때도 원래는 위와 같은 절차

를 거쳐야 한다. 하지만 개발자의 편의를 위해 이런 것을 잘 몰라도 원하

는 인터페이스를 생성해주는 도우미 함수들(Helper Function)이 제공되기

때문에 큰 걱정을 할 필요는 없다.

다이렉트X는 COM을 기반으로 하기 때문에 확장성이 뛰어나다. 아무리 확장

성이 뛰어나도 이전 버전과의 호환성이 유지되지 않는다면 별 의미가 없

을 것이다. 예를 들어 다이렉트 드로우 프로그래밍을 하다보면

IDirectDrawSurface2를 볼 수 있다. 초창기에 다이렉트 드로우 프

로그래밍을 한 사람들은 IDirectDrawSurface만 보았을 것이다. 2가 붙

었으니까 무엇인가 개선된 버전이란 느낌은 들 것이다. 다이렉트X에서는 어

떤 인터페이스의 기능에 추가가 필요하면 기존의 인터페이스는 그대로 놔

둔 채 새로운 인터페이스를 만들어낸다.

그래서 이전에 만들어진 프로그램들은 옛날의 인터페이스를 사용해 동작

하고 새로 만들어지는 프로그램들은 새로 추가된 인터페이스를 사용해 만들

어 질 수 있도록 하는 것이다. 이러한 다이렉트X만이 갖는 특징이 아니고

바로 COM의 특징이다.

- the end of this article -

less..

less..

 

그림 4 : 다이렉트 드로우의 구조

다이렉트 드로우는 한마디로 비디오 메모리 관리자로 윈도 GDI와 호환을 유

지하면서 직접 디스플레이 디바이스에 접근할 수 있는 소프트웨어 인터페

이스라고 할 수 있다. 다이렉트 드로우를 통해 게임 개발자들은 이제 더 이

상 수많은 하드웨어 드라이버 인터페이스를 맞추는 작업을 하지 않고도 GDI

를 거치지 않는 하위레벨 API로 하드웨어를 직접 제어할 수 있게 되었다.

즉 그래픽 디바이스에 상관없이, 또 윈도 디바이스 드라이버 계층을 거치

지 않기 때문에 보다 간단하게 그래픽 루틴을 구현할 수 있고 빠른 처리

속도를 기대할 수 있게 되었다.

특히 다이렉트 드로우는 하드웨어 가속에 관한 많은 기능을 부여하고 있

다. 다이렉트 드로우는 하드웨어와 데이터를 주고받기 위한 수단으

로 HAL (Hardware Abstraction Layer)이란 모듈을 사용한다. 사용하고

자 하는 기능이 하드웨어에 있는 것이라면 그것을 이용하고 만일 없다면

소프트웨어적으로 처리하기 때문에 고성능의 하드웨어에서는 더 빠르고

정확하게 기능이 구현되고 성능이 좋지 않은 하드웨어에서도 원하는 기능

이 동작한다.

이렇게 하드웨어적으로 지원되지 않는 기능을 소프트웨어적으로 구현하기

위해 HEL(Hardware Emulation Layer)이라는 모듈이 지원된다. 간단히 정리

해 보면 다이렉트X의 등장과 발전으로 인해 거의 완벽한 하드웨어 독립성

이 가능해졌고 이 때문에 게임 개발자들이 더 이상 자신만의 독자적인 드라

이버를 제작할 필요가 없어져 게임 제작 고유의 작업에 몰두할 수 있게 되

었다는 의미로 받아들이면 된다.

용어 정리 다이렉트 드로우를 이용한 프로그래밍에 들어가기에 앞서 몇 가

지 알아두어야 할 용어들과 개념이 있다. 일단 그것부터 정리하고 들어가

도록 하겠다.

비디오 모드비디오 모드란 화면의 해상도와 표현 가능한 색상수를 말한

다. 먼저 해상도에 대해 언급하면 다음과 같은 해상도가 대표적인 해상도들

이다.

320×200, 320×240, 640×400, 640×480, 800×600,

1024×768, 1280×1024, 1600×1200

현재 게임 환경으로 가장 널리 사용되는 해상도는 320×200과 640×480이

다. 예제 프로그램에서는 640×480을 사용할 것이다. 표현 가능한 색상수

는 결국 한 점의 색상을 표현하기위해 어떤 방법을 쓰느냐에 따라 달라진

다. 여기에는 크게 인덱스 모드와 RGB 모드가 있다. 인덱스 모드란 별도

의 색상 테이블을 두고 거기에 색상을 RGB로 정의해 둔 다음 이 테이블에

서 인덱스로 한 점의 색상을 표현하는 것이다. 널리 사용되는 색상 표현 방

법으로는 다음과 같은 것이 있다.

- 1, 2, 4, 8비트 인덱스 모드

- 16비트(64K개의 색상) ‘하이 컬러(High Color)’ 모드

- 24비트(16.7M개의 색상) ‘트루 컬러(True Color)’ 모드

- 32비트 RGBA 모드

8비트 인덱스 모드는 256개의 색상을 표현할 수 있는 모드로 흔히 256컬러

모드라고 한다. 즉 한 점을 나타내는데 8비트를 사용하며 이 값은 컬러 테

이블에서의 인덱스가 되는 것이다. 예를 들어 8비트 모드에서 어떤 점의

값이 5였다면 그 점의 실제 색상은 색상의 테이블의 5번째 항목에 어떤 값

이 들어있는지를 봐야만 알 수 있다. 인덱스 모드를 팔레트(Palette) 모드

라고 하기도 한다.

팔레트란 앞서의 컬러 테이블을 말한다.

===============================================================

인덱스 모드의 장점

1) 메모리를 덜 차지한다. 물론 그 만큼 표현가능한 색상의 수는 줄

어든다.

2) 메모리를 덜 차지하는 만큼 출력 속도가 빠르다.

3) 색상 테이블의 내용을 변경하여 여러 가지 효과를 낼 수 있다. 색

상 테이블의 내용을 변경하면 그 것이 바로 화면에 반영되기 때

문이다. 이를 이용해 페이드인(fade-in)이나 페이드아웃(fade-out)

효과를 낼 수 있다.

===============================================================

‘하이 컬러’모드는 하나의 색상을 표현하는데 16비트를 사용한다. RGB로

색상을 표현하는데 R, G, B 각각에 5비트, 6비트, 5비트씩을 할당한다. 24

비트 모드는 R, G, B 각각에 8비트씩을 할당한다. 32비트 RGBA 모드는 R,

G, B 각각에 8비트씩을 할당하고 마지막 한 바이트로 불투명도를 나타낸

다. 한 점을 표현하기 위해 사용하는 비트수가 많으면 많을수록 좋겠지만

그만큼 메모리를 많이 차지하게 된다. 예제 프로그램에서는 8비트 인덱스

모드를 사용해보겠다.

비트맵

컴퓨터 상에서 점의 배열 형태로 저장되는 이미지를 말한다. 기본적으로

컴퓨터상의 모든 그림은 비트맵이라고 할 수 있을 것이다. 여기서 비트맵

은 BMP 파일 형식을 이야기하는 것은 아니다.

스프라이트(Sprite)

투명한 영역이 존재한다는 점만 제외하면 기본적으로 비트맵과 같다. 스

프라이트는 게임에서 아주 중요한 요소이다. 게임의 배경 화면 위에서 움직

이는 모든 것들은 스프라이트로 만들어져야 한다.

만일 움직이는 것이 사각형 모양이라면 스프라이트로 만들 필요가 없지만

예를 들어 사람이라면(완전히 네모난 체형의 사람이 아니라면) 그냥 배경

위에 덮어써질 경우 겹쳐지는 부분의 배경 화면이 지워져 버린다. 그래서

스프라이트에는 투명 영역이 주어지는데 이는 대개 특정 색상을 지정해 이

것이 사용되면 투명 영역으로 인식한다. 이런 용도의 색상을 다이렉트

드로우에서는 컬러키(Color Key)라고 한다. 여기에는 소스 컬러키

(Source color key)가 있고 타겟 컬러키(Destination color key)가 있는

데 이에 대해서는 뒤에서 예제 프로그램을 만들어볼 때 다시 설명하도록

하겠다.

그림 5 : 스프라이트

스프라이트를 이용한 애니메이션에서 중요한 일 두 가지는 다음과 같다.

경계 검사(Bounds checking)

스프라이트의 이동 영역을 제한하는 것을 말한다. 이는 다이렉트 드로우

에서 직접 지원되지 않는 서비스로 개발자가 다이렉트 드로우를 기반으로

하여 직접 구현해야 한다.

충돌 검사(Collision detection)

하나 이상의 스프라이트가 충돌했는지 여부를 감지하는 절차를 말한다.

이 역시 다이렉트 드로우에서 직접 지원되지 않는 서비스로 개발자가 다이

렉트 드로우를 기반으로 하여 직접 구현해야 한다.

더블 버퍼링(Double Buffering)

게임이나 어떤 응용프로그램상에서 애니메이션을 수행해야 한다면 여러

가지 방법을 사용할 수 있다. 게임을 마치 영화처럼 생각해보자. 영화는

각 장면장면(이를 프레임이라 한다)을 계속적으로 촬영하여 이를 재생하

는 방법을 사용한다. 즉, 영화상에서 움직이는 대상들도 알고 보면 정지 화

면이 계속적으로 뿌려져 움직이는 듯한 효과를 내는 것이다. 바로 사람 눈

의 잔상 효과를 이용한 것이다. 잔상 효과를 얻으려면 1초에 프레임이 적어

도 30개 이상은 있어야 한다.

게임에서의 애니메이션도 마찬가지 원리이다. 배경 화면위의 캐릭터들을

그려놓고 그 것들의 위치를 조금씩 변경해가며 주기적으로(1초에 30번 이

상) 반복하여 그려주면 보는 사람 입장에서는 움직이는 것처럼 보인다.

이 방법으로 가장 널리 사용되는 것이 바로 더블 버퍼링이다. 다이렉트 드

로우도 더블 버퍼링을 사용하여 애니메이션을 수행한다. 여기에는 크게 두

가지 방식이 있다. 첫 번째 방식은 오프스크린 메모리(비디오 메모리가 아

닌 일반 메모리)에 다음 장면을 다 그려놓고 이를 한 번에 비디오 메모리

로 복사하는 과정을 반복하는 것이다.

바로 비디오 메모리로 써넣으면 배경 비트맵이 출력되고 각각의 스프라이

트가 출력되는 과정이 별도로 일어나기 때문에 사용자가 보기에는 깜빡이

는 듯한 현상이 발생한다. 이를 해결하기위해 일단 메모리의 별도 영역에

출력을 다 내보낸 다음 이를 한 번에 비디오 메모리로 복사하는 것이다. 이

는 일반 시스템 메모리의 내용을 비디오 메모리로 복사하는 것을 소프트웨

어적으로 해결하는 셈이기 때문에 다소 속도가 느리다.

두 번째 방법은 첫 번째 방법과 개념적으로 동일한데 하드웨어의 기능을

이용하기 때문에 훨씬 더 빠르다. 이 방법은 페이지 플립핑(Page

Flipping)을 이용하는 것이다. 먼저 두 개의 페이지를 만든다. 첫 페이

지를 전위 버퍼(Front Buffer)라 하고 다른 한 페이지를 후위 버퍼(Back

Buffer)라 한다. 전위 버퍼는 비디오 메모리에 위치하여 화면으로 출력되

는 내용을 담는다. 후위 버퍼는 비디오 메모리(가능하다면)나 시스템 메모

리에 위치하여 앞서 첫 번째 방법에서의 오프스크린 메모리와 같은 역할

을 수행한다. 이렇게 두 개의 페이지를 만든 다음 후위 버퍼에 다음 장면

을 다 그리고 나서 하드웨어에 페이지 플립핑 명령을 내리면 두 개의 페이

지가 교체된다. 즉, 후위 버퍼가 전위 버퍼가 되고 전위 버퍼가 후위 버퍼

가 된다. 결국 후위 버퍼에 써넣은 내용이 화면으로 출력되는 것이다.

이는 하드웨어적으로 화면에 뿌릴 내용을 읽어올 주소만 바꿔버리는 형식

이기 때문에 첫 번째 방법에 비해 훨씬 더 빠르다. 이렇게 페이지를 교체

해버리는 것을 페이지 플립핑이라 한다.

===============================================================

비디오 메모리

비디오 메모리란 모니터로 출력될 내용이 들어가 있는 메모리를 말한다.

이 메모리에 있는 내용이 약간의 차이는 있지만 대략 1초에 70회 정도 반

복적으로 모니터로 출력되는 것이다.

===============================================================

다이렉트 드로우에서는 이 두 가지 방식을 모두 지원한다. 다이렉트 드로

우를 사용하는 프로그램은 윈도 모드나 풀스크린 모드로 동작할 수 있다.

윈도 모드란 여타 다른 윈도 프로그램처럼 윈도를 갖는 프로그램으로 실행

되는 것을 말한다. 즉 다른 윈도 프로그램(GDI를 사용해 출력하는 프로그

램)들과 공존하는 것이다. 풀스크린 모드란 전제 화면을 다 차지하여 독점

하는 것이다. 즉 다른 윈도 프로그램들은 보이지 않게 된다. 윈도 모드에

서는 더블 버퍼링 방법 중 전자의 방법을 취하게 되고 풀스크린 모드에서

는 후자의 방법을 택해야 한다.

클립핑(Clipping)

전체 그림 영역 중에서 일부 영역만 출력하도록 하고 나머지 영역의 출력

은 막는 기술을 말한다. 우리가 지금 사용하고 있는 윈도도 모두 클립핑을

사용하고 있다. 즉 윈도마다 자신이 유지하는 내용을 모두 다 표시하는 것

이 아니라 자신의 크기에 맞춰 그 부분만 출력하고 나머지는 출력하지 않

는다. 이 것이 바로 클립핑이다. 다이렉트 드로우를 풀스크린 모드로 사용

할 때는 클립핑이라는 것이 필요없다. 전체 화면을 모두 내가 사용하는데

신경쓸 일이 없다. 하지만 윈도 모드의 다이렉트 드로우 프로그램에서는

이를 명심해야 한다. 출력이 자신이 속한 윈도 바깥으로 나가지 않도록

주의해야 한다. 다이렉트 드로우에는 이런 용도로 클립퍼(Clipper)라는 객

체가 제공된다. 앞서 이야기된 것처럼 이 객체는 윈도 모드에서만 사용된

다.

그림 7을 보면 윈도 A는 윈도 B와 C에 의해 가려져 있다. 이 경우 윈도 A

의 내용은 윈도 B와 C에 의해 가려진 부분을 제외하고 출력된다. 이것이 바

로 클립핑이다.

면(Surface) 객체

다이렉트 드로우에서 기본적으로 출력 대상이 되는 비트맵이나 스프라이

트의 내용을 보관하기위해 면(surface)이라는 것을 사용한다. 또한 앞서 더

블 버퍼링에서 버퍼도 면으로 표현한다. 전위 버퍼를 다이렉트 드로우

용어로는 주면(Primary Surface)이라 하고 후위 버퍼를 후위 면(Back

Surface)이라 한다. 앞에서 이야기한 것처럼 배경이 되는 비트맵이나 애니

메이션의 대상이 되는 스프라이트들도 각기 면 객체로 생성되어 있어야만

후위 면으로의 복사가 용이하다.

===============================================================

주 의

더블 버퍼링을 사용할 때는 한 가지 주의할 점이 있다. ‘찢어짐(teari

ng)’ 현상이 바로 그것인데 모니터 화면은 대개 1초에 70회 정도 다시 그

려진다. 비디오 메모리에 있는 내용을 별 생각이 없이 1초에 70번씩 가져다

가 그리는 셈인데 만일 화면의 내용이 중간쯤 그려진 상태에서 버퍼의 전환

이 이루어져 비디오 메모리의 내용이 변경된다면 화면의 하단이 먼저 그려

지고 상단이 그려질 것이다. 이는 순간적으로 사용자의 눈에 무엇인가 이상

한 느낌을 주게 된다. 이를 피하려면 버퍼의 전환이 이루어지는 시점을

잘 맞추어야 한다. 즉, 화면의 갱신이 모니터 화면의 수직 주사에 맞추어

버퍼를 교체해야 한다.

면 객체는 ‘유실(lost)’되는 경우가 있다. 다이렉트 드로우는 기존의 윈

도 출력 시스템인 GDI와 공존한다. 그런데 문제는 GDI는 다이렉트 드로우

란 놈의 존재를 모르고 있다는 것이다. 그래서 만일 다이렉트 드로우 프

로그램을 실행해 놓은 상태에서 다른 일반 윈도 프로그램을 전면으로 띄우

면(풀스크린 모드에서도 Alt+Tab키를 이용해 일반 윈도 프로그램으로의 전

이가 가능하다) 욕심많은 GDI는 그동안 다이렉트 드로우가 힘들게(?) 만들

어 놓은 자원들을 모두 회수해버린다. 다이렉트 드로우 입장에서 볼 때는

엉망이 되는 것이다. 이를 면이 유실되었다고 한다. 이 경우에는 면 객체

의 내용을 다시 복구해주어야 한다.

면의 유실 여부는 면의 메소드를 사용할 때 리턴 값을 보면 알 수 있다.

===============================================================

오버레이(Overlay)

개념적으로 볼 때 주 면에 적용되어 주 면을 덮고 있는 사각형의 영역으로

볼 수 있다. 오버레이는 다른 면 객체들보다 앞에 항상 떠 있다고 생각하

면 된다.

오버레이는 이를 하드웨어적으로 지원하는 그래픽 카드에서 잘 동작한다.

예를 들어 자동차 경주 게임이나 비행 시물레이션을 보면 게기판을 볼 수

있는데 이를 오버레이로 만들어 두면 된다.

다이렉트 드로우 관련 객체

다이렉트 드로우는 여러 개의 객체로 구성된다. 각각의 객체는 서로 상관

관계를 갖게 되며 여러 개의 멤버 함수를 갖게 된다. 다이렉트 드로우는 다

음과 같은 객체로 구성된다.

■다이렉트 드로우(DirectDraw) 객체

■다이렉트 드로우 면(DirectDrawSurface) 객체

■다이렉트 드로우 팔레트(DirectDrawPalette) 객체

■다이렉트 드로우 클립퍼(DirectDrawClipper) 객체

역시 메인이 되는 객체는 다이렉트 드로우이다. 이 객체를 통해 다른 객체

들의 생성이 가능한데 이 방법이 가장 널리 사용되는 방법이다. 각각의 객

체를 별도로 생성하는 것도 가능하다. 다이렉트 드로우 객체는 화면 해상

도를 지정하고 풀스크린 모드와 윈도 모드 중에 어떤 것을 사용할지와 다

른 다이렉트 드로우 객체들을 생성하는 역할을 담당한다.

다이렉트 드로우 면 객체는 실제 화면 출력과 관련되는 객체로 대개의 경

우 적어도 주 면 객체와 후위 면 객체의 두 개를 만들어 사용하게 된다.

다이렉트 드로우 팔레트 객체는 면 객체로 나가는 출력에서 어떤 색상을 사

용할 것인지 그 팔레트를 지정하는 역할을 담당한다. 다이렉트 드로우 클

립퍼 객체는 윈도 모드에 나가는 출력이 다른 윈도들의 영역을 침범하는 것

을 막는 역할을 담당한다.

다이렉트 드로우 프로그램 작성

이제부터는 다이렉트 드로우로 예제 프로그램을 작성해가면서 다이렉트 드

로우에 대해서 설명하도록 하겠다. 앞서 이야기했던 것처럼 예제 프로그램

은 윈도 API를 갖고 작성하도록 하겠다. MFC로 작성하게 되면 MFC 자체에

대한 지식이 필요하기 때문에 다이렉트 드로우 자체에 대해 집중할 수가 없

기 때문이다. 그리고 델파이나 비주얼베이식에서는 사용 가능한 다이렉트

드로우 컴포넌트가 있기는 하지만 이 것을 사용하면 다이렉트 드로우 자체

에 대해 제대로 이행할 수 없기 때문에 독자 여러분들이 다소 생소한 느낌

을 가질지 모르겠지만 API를 이용해서 예제 프로그램을 작성하겠다. 따라

서 여러분은 API를 이용한 프로그래밍에 대한 사전지식이 필요하다. 아주

잘 알아야할 필요는 없지만 적어도 “Hello, world?”를 출력하는 정도의

프로그램을 작성하고 그 내용을 이해할 수 있는 수준은 되어야 한다. 만들

고자 하는 프로그램은 풀스크린 모드의 프로그램이며 슈팅 게임의 기본적

인 뼈대만을 잡은 것으로 배경 화면이 스크롤되고 비행기 한 대가 키 입력

에 따라 위아래와 좌우로 이동하는 것이다.

- 계속 -

- the end of this article -

less..

less..

 

===============================================================

리스트 1 : WinMain의 내용

---------------------------------------------------------------

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE
    hPrevInstance, LPSTR lpCmdLine, int nCmdShow){

     MSG msg;
     HWND hwnd;
     WNDCLASS wc;

     // 윈도 클래스를 등록한다.
     wc.lpszClassName = "MAIN";
     wc.hInstance = hInst;
     wc.lpfnWndProc = WndProc;
     wc.style = CS_HREDRAW|CS_VREDRAW;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hIcon = LoadIcon (NULL,IDI_APPLICATION);
     wc.hCursor = LoadCursor (NULL, IDC_ARROW);
     wc.hbrBackground= (HBRUSH)GetStockObject (WHITE_BRUSH);
     wc.lpszMenuName = NULL;
     RegisterClass (&wc);

     // 메인 윈도를 생성한다.
     hwnd = CreateWindow ("MAIN", "DirectDraw Test",
          WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
          NULL, (HMENU)NULL, hInst, NULL);
     ShowWindow (hwnd,nCmdShow);
     UpdateWindow (hwnd);

     // 루프를 돌며 프레임을 갱신한다.
     for(;;){

     // 읽어올 메시지가 있는지 검사한다.
     if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
          if (GetMessage(&msg, NULL, NULL, NULL)) {
          // 있으면 가져온다.

          // 종료 메시지가 아니면 이를 처리한다.
               TranslateMessage(&msg);
               DispatchMessage(&msg);
          } else // 종료 메시지가 발생했으면 그냥 끝낸다.
               break;
     }

     if (bPlaying) // 게임이 진행 중이면
          UpdateFrame(); // 프레임을 변환한다.
     else // 진행 중이지 아니면
          WaitMessage();// 메시지가 발생하기를 기다린다.

     // 키 눌림 체크
     if (GetAsyncKeyState(VK_ESCAPE) < 0)

     // ESCAPE키가 눌렸으면 빠져나간다.
          break;

} ......

return msg.wParam;

}

===============================================================

예제 프로그램의 시작

다이렉트 드로우를 사용하려면 제일 먼저 해야할 일은 ddraw.h라는 헤더 파

일을 포함하고 ddraw.lib라는 라이브러리 파일을 링크시 라이브러리 항목으

로 지정하는 일이다. 라이브러리 항목으로의 지정은 Project 메뉴의

Settings 명령을 이용하면 된다. 이 명령을 실행하여 Link 탭을 택한 다

음 Category 박스로 General을 선택한다. 그 다음 Object/Library

modules 박스에 ddraw.lib를 추가한다(그림 8 참조)

모든 윈도 프로그램은 WinMain으로 시작한다. WinMain의 내용은 리스트 1

과 같이 작성한다.

그림 8 : ddraw.lib를 라이브러리 항목에 추가하기

리스트 1의 함수를 보면 다이렉트 드로우를 이용한 프로그램의 전체적인

흐름을 볼 수 있다. 윈도 클래스를 등록하고 메인 윈도를 생성하는 부분은

여타 윈도 프로그램과 다를 것이 없다. 중요한 부분은 바로 그 뒤를 이어

나오는 메시지 처리 루프이다. 이 루프의 모양을 보면 우리가 흔히 보아왔

던 메시지 루프의 처리 방법과는 상당히 상이함을 알 수 있다.

API 프로그램을 상당히 해보았다고 자신하는 사람들도 PeekMessage

나 WiatMessage와 같은 API에 대해서는 생소하게 느낄 것이다. 이 루프의

내용을 조금 더 알기 쉽게 그려보면 다음과 같다.

for(;;) {

// 처리할 메시지가 있으면 처리한다.
// 만일 종료 메시지가 들어왔으면 루프를 끝낸다.
// 게임이 진행중이면(bPlaying이라는 변수로 판단한다)
// 다음 화면을 그려서 뿌린다(UpdateFrame)
// 게임이 진행중이지 않으면 처리할 메시지가 발생하기를 기다린다.
// ESC키가 눌렸는지 검사하여 눌렸으면 루프를 끝낸다.

}

이 프로그램에서도 애니메이션을 수행하기 위해 더블 버퍼링을 사용한

다. 이 더블 버퍼링은 앞서 설명했듯이 영화처럼 장면을 계속적으로 만들어

내는 방식을 취한다. 즉, 다음 장면을 만들어 이를 페이지 플립핑을 통해

비디오 메모리로 전환하는 방식을 취하는 것이다. 그 핵심이 되는 함수가

바로 UpdateFrame이다.

이 함수의 내용은 뒤에서 살펴보겠지만 여기에 바로 이 예제 프로그램의

포인트가 있다. 이에 대해서는 뒤에서 살펴보고 다음으로 다이렉트 드로

우 객체의 초기화 방법에 대해 살펴보자.

다이렉트 드로우 객체의 초기화

일단 다이렉트 드로우 객체를 대표하는 전역 변수를 하나 선언한다.

// DirectDraw 관련 변수

LPDIRECTDRAW pDirectDrawObj; // DirectDraw 객체

다이렉트 드로우 객체를 생성하여 그 값을 위의 변수에 저장해두어야 한

다. 이 작업은 메인 윈도의 WM_CREATE 메시지 처리부에서 수행하도록 하

겠다.

WM_CREATE 메시지는 윈도가 생성되자마자 발생하는 메시지로 델파이나 비

주얼베이식으로 치면 OnLoad 이벤트에 해당한다.

switch (message){
// 변수를 초기화한다.

case WM_CREATE:
{
     pDirectDrawObj = NULL;
     ....

     // ----------------------------------
     // DirectDraw 관련 초기화를 수행한다.
     // ----------------------------------

     // DirectDraw 객체를 생성한다.
     if (DirectDrawCreate(NULL, &pDirectDrawObj, NULL) != DD_OK)
          return -1;

     // 프로그램을 독점 모드와 전체 화면 모드로 띄운다.
     if (pDirectDrawObj->SetCooperativeLevel(hWnd,
           DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN)!= DD_OK)

     return -1;

     // 화면 해상도를 설정한다. (640X480)의 256 컬러 모드
     if (pDirectDrawObj->SetDisplayMode(640, 480, 8)!= DD_OK)
          return -1;

     ....

먼저 다이렉트 드로우 객체를 생성하고 그것의 협동 모드와 비디오 모드

를 설정하였다. 다이렉트 드로우 객체를 생성하기 위해서는

DirectDrawCreate라는 다이렉트 드로우의 도우미 함수를 이용하였다. 두

번째 인자로 생성되는 다이렉트 드로우 객체에 대한 포인터를 얻어올 변수

의 주소를 지정하였다. 모든 다이렉트 드로우 관련 함수들은 성공적으로 종

료될 경우 리턴값이 DD_OK가 된다는 점도 하나 알아두기 바란다. 여기서 사

용된 다이렉트 드로우 관련 함수들에 대한 레퍼런스는 뒷 부분에 별도로 모

아두었으니 참고하기 바란다.

아무튼 DirectDrawCreate 함수의 호출이 성공적으로 끝나면

pDirectDrawObj 변수에는 생성된 다이렉트 드로우 객체의 주소가 들어가게

된다. 그 다음에 바로 해야할 일은 다이렉트 드로우가 풀스크린 모드로 실

행될 것인지 아니면 윈도 모드로 실행될 것인지를 지정하는 것이다. 이 일

을 수행하기 위해서는 다이렉트 드로우 객체의 SetCooperativeLevel이란 함

수를 호출해야 한다. 풀스크린 모드로 실행되려면 두 번째 인

자로 DDSCL_EXCLUSIVE | DDSCL_FULLSCRE EN을 주어야 한다. 윈도 모드

로 실행되려면 두 번째 인자로 DDSCL_NORMAL을 주어야 한다. 여기서는 풀스

크린 모드로 뜰 것이기 때문에 DDSCL_EXCLUSIVE와 DDSCL_ FULLSCREEN을 주

었다.

다음으로 비디오 모드를 설정하기 위해 다이렉트 드로우의 SetDisplayMode

함수를 호출하였다. 첫 번째 인자와 두 번째 인자로는 가로와 세로 해상도

를 지정한다. 여기서는 640×480을 사용하였다. 마지막 인자로는 한 점의

색상을 표현하기 위해 사용할 비트수를 지정한다. 여기서는 8을 지정했기

때문에 256컬러를 사용하는 인덱스 모드가 된다.

인덱스 모드를 사용할 때는 어떤 컬러 테이블을 사용할 것인지도 지정해주

어야 한다. 뒷 부분에 보면 다이렉트 드로우 팔레트 객체를 생성하는 것을

볼 수 있을 텐데 여기서 어떤 컬러 테이블을 사용할 것인지 지정하는 방법

을 볼 수 있을 것이다. 이 것으로 다이렉트 드로우 객체의 생성과 초기화

는 끝이 났다.

===============================================================

리스트 2 : CreateSurfaces 함수

---------------------------------------------------------------

// ----------------------------------------------
// CreateSurfaces : 전위 면과 후위 면을 생성한다.
// ----------------------------------------------

BOOL CreateSurfaces()
{
     DDSURFACEDESC ddSurfaceDesc;
     DDSCAPS ddsCaps;
     BOOL bSuccess = FALSE;
     HRESULT hResult;

     // 전위 면을 하나의 후위 버퍼 면을 갖도록 생성한다.
     // 먼저 DDSURFACEDESC 구조체를 초기화한다.
     memset(&ddSurfaceDesc, 0, sizeof(DDSURFACEDESC));
     ddSurfaceDesc.dwSize = sizeof(DDSURFACEDESC);
     ddSurfaceDesc.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
     ddSurfaceDesc.ddsCaps.dwCaps
        = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;

     ddSurfaceDesc.dwBackBufferCount = 1;

     // 전위 면을 생성한다.
     hResult = pDirectDrawObj->CreateSurface
             (&ddSurfaceDesc, &pPrimarySurface, NULL);

     if (hResult == DD_OK) {

          // 후위 버퍼 면의 포인터를 만든다.
          ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
          hResult = pPrimarySurface->GetAttachedSurface
               (&ddsCaps, &pBackSurface);

          if (hResult == DD_OK)
               bSuccess = TRUE;
     }

     return bSuccess;

}

===============================================================

면 객체의 생성

이제 해야할 일은 면 객체를 생성하는 것이다. 다이렉트 드로우의 페이지

플립핑을 이용한 스프라이트 애니메이션을 수행해 볼 것이기 때문에 전

위 버퍼와 후위 버퍼를 생성해야 한다. 앞서 이야기했듯이 다이렉트 드

로우에서는 전위 버퍼를 주면(Primary Surface)이라 하고 후위 버퍼를 후

위 면(Back Surface)라고 한다.

이 밖에도 후위 면에 화면을 구성하는데 사용될 비트맵이나 스프라이트들

도 면 객체(이런 면들을 오프스크린 면이라고 하기도 한다)로 구성되어야

한다. 먼저 주 면 객체와 후위 면 객체의 생성 절차를 살펴보자. 관련 변수

들을 일단 전역 변수로 정의한다.

LPDIRECTDRAWSURFACE pPrimarySurface; // 주 면 객체

LPDIRECTDRAWSURFACE pBackSurface; // 후 면 객체

이 객체들 역시 WM_CREATE 메시지 처리부에서 다이렉트 드로우 객체의 생

성이 끝나자마자 생성하게 된다.

....

// 전위 면과 후위 버퍼 면을 생성한다.

if (CreateSurfaces() == FALSE)

return -1;

....

주 면과 후위 면 객체의 생성을 위해 CreateSurfaces라는 함수를 별도로

만들어 두었다. 이 함수의 내용은 리스트 2와 같다.

면 객체를 생성하는데는 다이렉트 드로우 객체의 Crea teSurface라는 함

수를 이용한다. 그런데 어떤 면을 생성할 것인지는 CreateSurface 함수

의 첫 번째 인자로 지정되는 DDSURFACEDESC 구조체에 지정하게 되어 있다.

이 구조체와 함수에 대해 자세한 사항은 뒤의 다이렉트 드로우 함수 레퍼런

스를 참고하기 바란다. 여기서는 간단히 설명만 하겠다. 이 구조체의

ddsCaps.dwCaps 필드에 어떤 면 객체를 생성할 것인지 지정하도록 되어 있

다.

여기서는 주 면 객체를 생성하기 위해 DDSCAPS_PRIM ARYSURFACE를 지

정하였고 이것이 페이지 플립핑에 사용되며 따라서 후위 면 객체의 생성도

필요하다는 점도 알리기위해 DDSCAPS_FLIP과 DDSCAPS_COMPLEX도 지정

하였다. 그리고 후위 면 객체는 하나만 생성할 것이란 점도 명시하기

위해 dwBackBufferCount 필드의 값은 1로 지정하였다.

사실 후위 면을 하나만 생성해야하는 것은 아니다. N개의 후위 면을 생성하

여 이것들을 주 면과 돌려가며 사용하는 것도 가능하다. 이렇게

DDSURF ACEDESC 구조체의 초기화가 끝나면 다이렉트 드로우 객체의

CreateSurface 함수를 호출한다. 이 함수의 호출이 성공적으로 끝나면

pPrimary Surface 변수에 생성된 다이렉트 드로우 면 객체의 주소가 들어온

다.

이 경우에는 주 면 객체의 주소가 들어오게 된다. 주 면 객체의 생성이 성

공적으로 끝나면 생성된 주 면 객체에서 후위 면 객체의 주소를 빼

내기위해 GetAttachedSurface 함수를 호출한다.

// 후위 버퍼 면의 포인터를 만든다.

ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

hResult = pPrimarySurface->

GetAttachedSurface(&ddsCaps, &pBackSurface);

주의할 것은 이 함수는 다이렉트 드로우 객체의 함수가 아니라 면 객체(여

기서는 주 면 객체)의 함수라는 점이다. 후위 면 객체에 대한 포인터

는 pBack Surface 가 받게 된다.

다음으로 배경 비트맵과 스프라이트로 사용될 면 객체의 생성에 대해 알

아보자. 이런 용도의 면 객체들을 담을 변수들을 전역 변수로 다음과 같

이 정의한다.

LPDIRECTDRAWPALETTE pDirectDrawPal; // 팔레트 객체

LPDIRECTDRAWSURFACE pBackground; // 배경 면 객체

LPDIRECTDRAWSURFACE pMainCharacter; // 메인 캐릭터 면 객체

여기서 주의할 것은 단순히 면 객체만 생성하면 끝나는 것이 아니라 관련

된 면 객체들에서 사용할 다이렉트 드로우 팔레트 객체도 생성해야 한다

는 점이다.

팔레트 객체가 필요한 점은 이 프로그램에서 다이렉트 드로우의 비디오 모

드를 8비트 인덱스 모드로 선택했기 때문이란 점은 다시 한 번 명심하기 바

란다.

그래서 다이렉트 드로우 팔레트 객체를 생성하여 그 주소를 보관하기

위해 pDirectDrawPal이란 전역변수를 정의하였다. pBackground는 배경이 되

는 비트맵을 보관하는데 사용되는 면 객체이다. pMainCharacter는 이 프로

그램에서 썰렁하게 돌아다닐 단 하나의 스프라이트 내용을 담는데 사용되

는 면 객체이다.

이 변수들의 초기화 역시 WM_CREA TE 메시지 처리부에서 수행하는데 앞서

의 주 면과 후위 면 객체의 초기화가 끝난 다음에 바로 수행한다.

// 배경 비트맵에 맞추어 DirecrDrawPalette를 생성한다.
if ((pDirectDrawPal = DXLoadPalette("MEDIA\\BACK0000.BMP")) == NULL)
     return -1;

// 팔레트가 성공적으로 생성되었다면 이를 설정한다.
//이 부분의 호출은 오프스크린면의 생성에 앞서 이루어져야한다.
if (pPrimarySurface->SetPalette(pDirectDrawPal)!= DD_OK)
     return -1;

// 배경 비트맵을 불러들여 오프스크린 면을 생성한다.
if ((pBackground = DXLoadBitmap("MEDIA\\BACK0000.BMP")) == NULL)
     return -1;

// 메인 캐릭터의 비트맵을 불러들여 오프스크린 면을 생성한다.
if ((pMainCharacter = DXLoadBitmap("MEDIA\\SHIP0000.BMP")) == NULL)
     return -1;

bDirectDrawOK = TRUE;

return 0;

}

필자는 배경과 스프라이트로 사용될 그림을 모두 MEDIA라는 디렉터리 밑

에 넣어두었다. BACK0000.BMP는 배경이 되는 그림이 들어가 있는 비트맵

파일(.BMP 파일)이고 SHIP0000.BMP는 주인공이 되는 비행기의 그림이 들어

가 있는 비트맵 파일이다.

BITMAPFILEHEADER

BITMAPINFOHEADER

칼라 테이블

비트맵 데이터

그림 9 : 비트맵 파일의 구조

제일 먼저 할 일은 주 면 객체의 컬러 테이블(팔레트)을 설정하는 일이

다. 즉, 주 면 객체에서 어떤 색상들을 사용할 것인지를 결정하는 것이

다. 모든 면 객체들이 결국은 주 면 객체를 통해서 출력이 나가게 되기 때

문에 주 면 객체에 어떤 팔레트를 설정하느냐는 문제는 아주 중요한 문제

가 된다. 그래서 여기서는 배경 그림의 팔레트를 읽어다가 주 면 객체에

설정하고 있다. 그렇게 하기위해 DXLoadPalette 함수를 호출하고 있다.

이 함수의 내용은 리스트 3과 같다.

DXLoadPalette 함수는 인자로 비트맵 파일의 경로를 받아서 그 파일의 컬

러 테이블 내용만 읽어들여서 다이렉트 드로우 팔레트 객체를 생성하여 그

것을 리턴한다. 리스트 3의 코드를 이해하려면(그냥 가져다 쓸려면 굳이

이해할 필요는 없지만) 비트맵 파일의 구조에 대해 알아야 한다. 비트맵 파

일의 구조를 간단히 보면 그림 9와 같다.

비트맵 파일의 맨 앞에는 BITMAPFILEHEADER라는 구조체가 들어온다. 그

래서 이 것이 비트맵 파일이며 실제 내용 데이터는 어디부터 시작하는지

등의 정보가 들어온다. 이 구조체의 뒤를 이어서 BITMAPINFOHEADER라는 구

조체가 따라온다. 이 구조체에는 이 파일에 포함된 비트맵 그림에 대한

정보가 들어온다. 예를 들면 폭과 높이는 얼마이고 한 점을 표현하는데

몇 비트를 사용하는지 등의 여부가 들어온다. 이 구조체의 뒤에는 바로 컬

러 테이블이 따라온다. 그런데 모든 비트맵 파일에 컬러 테이블이 따라오

는 것은 아니다. 인덱스 모드로 저장된 비트맵 파일의 경우에만 컬러 테이

블이 필요하지 하이 컬러나 트루 컬러와 같이 점의 값으로 아예 색상 코드

(RGB)가 들어간 경우에는 컬러 테이블이 필요하지 않기 때문이다. 컬러 테

이블은 PALETT EENTRY 구조체의 배열로 구성된다.

여기서는 아예 256개의 항목을 갖는 테이블을 구성한다고 가정했기 때

문에 PALETTEENTRY 배열을 256개로 고정하였다.

PALETTEENTRY ape[256];

===============================================================
리스트 3 : DXLoadPalette 함수
---------------------------------------------------------------

// -----------------------------------------------
// DXLoadPalette : 지정된 비트맵 파일의 팔레트를 바탕
// 으로 팔레트 객체를 생성한다.
// -----------------------------------------------

IDirectDrawPalette *DXLoadPalette(LPCSTR lpBitmapFilename)
{
     IDirectDrawPalette* ddpal;
     int i;
     int n;
     int fh;
     PALETTEENTRY ape[256];

     if (lpBitmapFilename && (fh=_lopen(lpBitmapFilename, OF_READ)) != -1){
          BITMAPFILEHEADER bf;
          BITMAPINFOHEADER bi;
          _lread(fh, &bf, sizeof(bf));

          // BITMAPFILEHEADER 구조체를 읽어들인다.
          _lread(fh, &bi, sizeof(bi));

          // BITMAPINFOHEADER 구조체를 읽어들인다.
          _lread(fh, &ape, sizeof(ape));

          // 컬러 테이블의 내용을 읽어들인다.
          // 일단 무조건 256개를 읽어들인다.

          _lclose(fh);

          // 변수 n으로는 컬러 테이블의 항목수를 계산한다.
          if (bi.biSize != sizeof(BITMAPINFOHEADER))
               n = 0;

          else if (bi.biBitCount > 8)

          // 한 점에 8비트 이상을 사용한다면 이는 인덱스
          // 모드가 아니다.
          n = 0;

          else if (bi.biClrUsed == 0)
               n = 1 << bi.biBitCount;

          else
               n = bi.biClrUsed;

          // 컬러 테이블의 내용을 다이렉트 드로우 팔레트의
          // 형식에 맞게 조정한다.

          for (i=0;i<n;i++) {
               BYTE r = ape[i].peRed;
               ape[i].peRed = ape[i].peBlue;
               ape[i].peBlue = r;
          }
     }

     if (pDirectDrawObj->CreatePalette(DDPCAPS_8BIT |
          DDPCAPS_ALLOW256, ape, &ddpal, NULL)!= DD_OK) {

          return NULL;
     } else {
          return ddpal;
     }
}

===============================================================

읽어들인 컬러 테이블의 내용은 다이렉트 드로우 객체의 CreatePalette 함

수를 이용해 다이렉트 드로우 팔레트 객체로 만들 수 있다. 그런데 여기

서 주의할 것은 한 색상을 표현하기 위해 사용하는 RGB의 배열 순서가

PALETTEENT RY 구조체와 CreatePalette 함수의 인자에서와 약간 다르다는

것이다.

그래서 이 순서를 맞추기 위해 CreatePalette 함수의 호출에 앞서 약간의

조정 작업을 수행하고 있다. Red와 Blue의 위치를 바꾸어 주기만 하면 된

다. 다이렉트 드로우 객체의 CreatePalette 함수를 호출할 때는 이 팔레트

가 256 색상을 갖는 것임을 명시하기 위해 인자로 DDPCAPS_8BIT |

DDPCAPS_ALLOW256을 준다. 결과로 생성된 다이렉트 드로우 팔레트 객체는

pDirectDrawPal이라는 변수에 저장되며 독립적으로 존재하는 객체가 된다.

이 객체를 다른 면 객체에서 사용하도록 하려면(즉, 면 객체에서 이 팔레

트 객체를 사용하도록 하려면) 면 객체의 SetPalette 함수를 사용해야 한

다. 그래서 DXLoadPalette 함수의 호출이 성공적으로 끝나면 다음과 같은

코드가 수행되고 있다.

// 팔레트가 성공적으로 생성되었다면 이를 설정한다.
// 이 부분의 호출은 오프스크린 면의 생성에 앞서 이루어져야 한다.
if (pPrimarySurface->SetPalette(pDirectDrawPal) != DD_OK)
     return -1;

이제 팔레트 객체의 생성과 그것을 주 면 객체에 연결하는 것이 끝났다.

다음으로 배경 비트맵과 비행기 스프라이트에 해당하는 면 객체를 생성하

는 일이 남았다. 이는 DXLoadBitmap이란 함수를 통해서 수행하는데 내용

은 리스트 4와 같다.

DXLoadBitmap 함수는 인자로 주어진 비트맵 파일을 로드하여 그 내용을 바

탕으로 오프스크린 면 객체를 생성한다. 그 과정에서 오프스크린 면 객체

자체를 생성하기 위해 CreateOffScreenSurface라는 함수를 호출하고 거기

에 비트맵 파일의 내용을 복사하기 위해 DXCopyBitmap이라는 함수를 사용한

다.

먼저 비트맵 파일의 내용을 읽어들이기 위해 LoadImage라는 API를 호출한

다. 이 함수의 리턴값으로는 비트맵 핸들이 넘어온다. 비트맵 핸들

을 인자로 GetObject라는 API를 호출하여 비트맵의 폭(bm.bmWidth)과 높

이(bm.bmHeight)를 알아낸 다음 이를 인자로 하여 오프스크린 면 객체를 생

성하기 위해 CreateOffScreenSurface 함수를 호출한다. 오프스크린 면 객체

의 생성이 성공하면 비트맵 파일의 내용을 복사하기 위해 DXCopyBitmap 함

수를 호출한다. 이제 CreateOffScreenSurface와 DXCopyBitmap 함수의 내용

을 살펴보자(리스트 5, 6 참조).

CreateOffScreenSurface 함수는 인자로 주어진 크기의 면 객체를 생성하

는 역할을 한다. 이 역시 다이렉트 드로우 객체의 CreateSurface 함수를 이

용하는데 생성하고자 하는 면 객체를 기술하는 DDSURFACEDESC 구조체의 초

기화 방법이 앞서 주 면 객체의 생성시와는 달라진다. DDSURFAC EDESC 구

조체의 ddsCaps.dwCaps 필드에는 DDS CAPS _OFFSCREENPLAIN라는 값을 지정

하고 dwWidth에는 폭을 지정하고 dwHeight 필드에는 높이를 지정한다. 생

성이 성공적으로 끝나면 컬러키를 지정한다. 컬러키의 생성에는

면 객체의 SetColorKey 함수를 이용한다. 첫 번째 인자로 DDCKEY_SRCBLT

를 주었기 때문에 소스 컬러키를 지정한 셈이 된다.

- 계속 -

- the end of this article -

less..

 more.. 
 less.. 
  
 
  기타   이 프로그램의 윈도 프로시저를 보면  WM_ACTIVATEAPP 메시지를 처리하
고 있다.   case WM_ACTIVATEAPP :
{
    if (wParam)        // 프로그램이 활성화되면 
    {
        bPlaying = TRUE;
        ShowCursor(FALSE);   // 커서를 숨긴다.
    }
    else // 프로그램이 후면으로 숨으면 
    {
        bPlaying = FALSE;
        ShowCursor(TRUE);    // 커서를 보이도록 한다.
    }
}   이 메시지는 윈도가 전면으로 나오게 되거나 후면으로 숨게 되면 발생하
는  메시지이다. 윈도 프로시저의 세 번째  인자인 wParam으로 이 윈도가  
전면으로 나오는 것인지   아니면 후면으로  숨는  것인지의 여부를   판단
할 수  있다. 
wParam이 TRUE이면 전면으로 나오는 것이고 FALSE이면 후면으로 숨는 것
이다. 여기서는 이 프로그램이 전면에 있을 때만 동작하도록 하려고 하기 
때문에 전면으로 나올 때만 bPlaying 변수의 값을 TRUE로 설정한다. 
또한 이 프로그램은 마우스를 사용하지 않는 프로그램이기 때문에 마우스 
포인터가 보인다면 이상할 것이다. 그래서 ShowCursor 함수를 이용해 커서
의 보임 여부도 조절하고 있다.  
앞서의 설명으로 다이렉트 드로우를 사용하는  간단한 프로그램을 살펴보았
다. 
이 프로그램에 추가로 다이렉트 사운드의 기능을 추가하는 음향 효과도 
낼  수 있을 것이다. 그리고 이 프로그램이 진짜 슈팅 게임이  되려면 여
러 개의 캐릭터를 추가해야하고 각 캐릭터간의 움직임이나 상관관계 등을 
정해서 코드를 작성해주어야 할 것이다. 캐릭터간의 충돌을 어떻게 체크할 
것인지 또 점수에 따라 움직임을 빠르게 한다든지 폭탄의 빈도를 높인다든
지 생각해주어야 할 것은 무궁무진할 것이다. 다만 이런 요소들은 다이렉
트 드로우를 기반으로 할 수 있는 것이지 다이렉트 드로우에서 해줄 수 있
는 것은 아니다.   다이렉트 드로우 레퍼런스
여기에서는 앞에서 사용했던 다이렉트 드로우 관련 함수들을 정리해보고자 
한다. 각 객체별로 정리하도록 하겠다.   다이렉트 드로우 객체의 멤버 함수
이 객체를 구성하는 멤버 함수는 대략 그 수가 20개 정도 되는데 그 중에
서 필요한 것들만 언급하도록 하겠다. 먼저 언급할 것은 다이렉트 드로우
의 멤버 함수가 아니라  다이렉트 드로우  객체를 생성해주는  역할을 하
는   DirectDraw Create 함수이다.   DirectDrawCreate 함수
이 함수는 다이렉트 드로우에서 가장 중요한 다이렉트 드로우 객체를 생성
해주는 함수이다. 다이렉트 드로우가 COM  인터페이스로 구성되어 있기는 
하지만 인터페이스의 생성까지 COM 프로그래밍에서 하듯이 하게되면  개발
자들이 부담감을 느낄 수 있기 때문에  이를 쉽게 해줄 수  있도록 별도의 
도우미 함수(Helper Function)를 제공해준다. 이런 함수는 다이렉트X의 다
른 구성요소에도 동일하게 적용된다. DirectDrawCreate 함수의 원형은 다음
과 같다.
HRESULT DirectDrawCreate(GUID FAR *lpGUID, LPDIRECTDRAW 
    FAR *lplpDD,  IUnknown FAR *pUnkOuter); 
인자를 설명하면 다음과 같다. 먼저 첫  번째 인자인 lpGUID는 생성하고자 
하는 다이렉트드로우   인터페이스의 이름에  해당하는  GUID(Globally  
Unique IDentifier)를 지정하는 부분이다. 대개 NULL을 지정하는데  그러
면 현재 설정된 디폴트 디스플레이 드라이버를 바탕으로 IDirectDraw 인터
페이스를 생성하여 그 포인터를 두 번째 인자인 lplpDD에 넣어 준다. 두 번
째 인자인 lplpDD는 실제로 생성된 IDirectDraw  인터페이스의 포인터를  
받는 부분으로 포인터의 포인터 타입임을 명심하기 바란다. 마지막 세  번
째 인자는 COM에 대한 상당한 지식을 필요로 하는  부분인데 일단 NULL로 
지정한다고만  알아두기 바란다.  COM에는   외부 Unknown이라는   것을  
통해   COM 객체간의   포함(aggregation)이 가능한데 이와 연관된 기능이
다. 인터페이스의  생성에 성공하면 리턴값은 DD_OK가 된다. 실패하면 에러
코드가 리턴된다.   SetCooperativeLevel 함수
풀스크린 모드를 사용할 것인지 아니면 윈도 모드를 사용할 것인지를 결정
하는 함수이다. 풀스크린 모드는 말그대로 화면 전체를  다이렉트 드로우
의 출력 범위로 만드는 것이다. 윈도 모드는  윈도를 하나 만들어 그  윈도
로만 다이렉트 드로우의 출력을 내보내는 것이다. 프로그램하기는 후자가 
더 까다롭다. 함수의 원형은 다음과 같다.
HRESULT SetCooperativeLevel(HWND hWnd, DWORD dwFlags);
 
첫 번째 인자인 hWnd는 다이렉트 드로우의 출력이  나갈 응용 프로그램의 
윈도 핸들이다. 두 번째 인자인 dwFlags는 표 3과 같은 값들을 가질 수 있
다(비트합도 가능하다). 윈도 98과 윈도  NT 5.0에서만 사용할 수 있는  플
래그들도 있는데 일단 여기서 설명은 제외하였다.
두  번째   인자에서 중요한   것은  DDSCL_EXCLUSIVE(풀스크린   모드)와 
DDSCL_NORMAL (윈도 모드)둘 중의 하나는 적어도 반드시 지정되어야 한다
는 점이다. 또 풀스크린 모드로 지정되었을 경우 그  전체 화면의 해상도
와 컬러 비트수를 지정하기 위해 SetDisplayMode와 같은 멤버 함수를  반드
시 호출해야 한다.   SetDisplayMode 함수
SetDisplayMode는 디스플레이 디바이스 하드웨어의 모드를 결정한다. 구 버
전의 다이렉트 드로우에서는 이 함수의  인자가 3개뿐이었는데 최근 버전에
서는 인자가 두 개  더 추가되었다.  다이렉트 드로우  관련 레퍼런스를  
보다 보면 IDirectDraw와 IDirectDraw2를 볼 수 있을텐데  이는 다이렉트 
드로우 객체에 해당하는 인터페이스를 지칭하는 COM 용어로 IDirectDraw2
가 바로 최신 버전의 다이렉트 드로우 객체에 해당하는  인터페이스이고 
IDirectDraw는 구 버전에 해당하는 인터페이스이다. 예제 프로그램에서는 
IDirectDraw를 사용하였다.   HRESULT SetDisplayMode(DWORD dwWidth, DWORD dwHeight, 
DWORD dwBPP,  DWORD dwRefreshRate, DWORD dwFlags);
첫 번째 인자와 두 번째 인자는 각각 새로운 모드의 폭과 높이를 픽셀 단위
로 지정한다. 세 번째 인자인 dwBPP는 새로운  모드의 픽셀 당 비트수를 지
정한다. 네 번째 인자는 리프레쉬율을 지정하는 부분인데  0을 지정하면 
구 버전의 다이렉트 드로우 객체의 SetDisplayMode를 호출한다. 마지막 인
자는 선택적인 인자로 0을 주거나  DDSDM_STAND ARDVGAMODE를  준다. 이 플
래그는 320x200x8 모드를 설정해버린다. 만일 다른 해상도나 비트 수를 사
용하려 한다면 마지막 인자의 값으로는 0을 지정해야 한다.
===============================================================
DDSCL_ALLOWMODEX         모드 X 디스플레이 모드를 사용한다. 이 플
                         래그가  사용되면  반드시  DDSCL_EXCLU 
                         SIVE, DDSCL_FULLSCREEN 플래그가 같
                         이 사용되어야 한다.
DDSCL_ALLOWREBOOT        풀스크린 모드에서   CTRL+ALT+DEL키가   
                         동작하도록 허용한다.
DDSCL_EXCLUSIVE          출력 관련 자원을 독점하겠다는 의미의 플래
                         그로 풀스크린   모드에서만 가능하기  때문 
                         에 DDSCL_FULLSCREEN   플래그와 같이   
                         사용되어야 한다.
DDSCL_FULLSCREEN         화면 전체를  다이렉트 드로우의 출력  화면 
                         으로 사용하겠다는 의미로  출력 관련  자원 
                         을   독점하겠다는   의미가  되기   때문에    
                         DDSCL_EXCLUSIVE 플래그와  같이  사용 
                         되어야 한다.
DDSCL_NORMAL             화면 전체가 아닌  윈도의 영역만을 다이렉 
                         트 드로우의 출력 영역으로 삼겠다는 의미의 
                         플래그이다. 이 플래그는 DDSCL_ALLOW
                         MODEX,  DDSCL_EXCLUSIVE,  DDSCL_ 
                         FULLSCREEN 플래그와 같이 사용될 수 없다.
DDSCL_ NOWINDOWCHANGES   다이렉트드로우의 출력이 나가는 윈도가 활
                         성화될 때‘최소화’,‘이전  크기로’의 기 
                         능이 동작하지 않도록 하고자 할 때 사용할 
                         수 있다.
===============================================================
표 3 : SetCooperativeLevel 함수에서 dwFlags의 값들   ===============================================================
 참고 1 : DDSURFACEDESC 구조체
---------------------------------------------------------------
■dwSize : 이 구조체의 크기를 바이트 단위로 지정한다. 
■dwFlags : 뒤에 나오는 다른 필드들 중에  어느 것이 의미있는 값인지 지
정한다. 다음과 같은 플래그들이 하나 이상 지정될 수 있다.   - DDSD_ALL : 모든 필드들이 다 사용된다.
- DDSD_ALPHABITDEPTH  : dwAlphaBitDepth 필드가 사용된다.
- DDSD_BACKBUFFERCOUNT : dwBackBufferCount 필드가 사용된다.
- DDSD_CAPS : ddsCaps 필드가 사용된다.
- DDSD_CKDESTBLT : ddckCKDestBlt 필드가 사용된다.
- DDSD_CKDESTOVERLAY : ddckCKDestOverlay 필드가 사용된다.
- DDSD_CKSRCBLT : ddckCKSrcBlt 필드가 사용된다.
- DDSD_CKSRCOVERLAY : ddckCKSrcOverlay 필드가 사용된다.
- DDSD_HEIGHT : dwHeight 필드가 사용된다.
- DDSD_LINEARSIZE : 사용되지 않는다.
- DDSD_LPSURFACE : lpSurface 필드가 사용된다.
- DDSD_MIPMAPCOUNT : dwMipMapCount 필드가 사용된다.
- DDSD_PITCH : lPitch 필드가 사용된다.
- DDSD_PIXELFORMAT : ddpfPixelFormat 필드가 사용된다.
- DDSD_REFRESHRATE : dwRefreshRate 필드가 사용된다.
- DDSD_WIDTH : dwWidth 필드가 사용된다.
- DDSD_ZBUFFERBITDEPTH : dwZBufferBitDepth 필드가 사용된다.   ■dwHeight, dwWidth : 생성하고자 하는 면의 폭과 높이를 픽셀 단위로 지
정한다.
■lPitch : 한 줄의 크기를 바이트 단위로 지정한다.
■dwBackBufferCount : 후면 객체의 수를 지정한다.
■lpSurface : 면과 관련된 메모리의 시작 주소. 면 객체의 Lock 함수를 부
르면 이 필드는 면 메모리에 대한 유효한 포인터를 유지하게 된다.
■ddckCKDestOverlay : 오버레이  면에 사용되는  목적지 컬러키를 기술하
는 DDCOLORKEY 구조체.
■ddckCKDestBlt : blit  작업에 사용되는  목적지 컬러키를  기술하는 
DDCOLORKEY 구조체
■ddckCKSrcOverlay :   오버레이 면에  사용되는  소스  컬러키를 기술하
는 DDCOLORKEY 구조체
■ddckCKSrcBlt : blit  작업에 사용되는  소스 컬러키를  기술하는 
DDCOLO RKEY 구조체 
■ddpfPixelFormat : 면의 픽셀 형식을 기술하는 DDPIXELFORMAT 구조체
■ddsCaps : 면이 수행할 수 있는 기능을 기술하는 DDSCAPS 구조체
===============================================================   CreateSurface 함수
실제 화면 출력에 사용되는 다이렉트 드로우 면 객체를 만들어준다. 함수
의 원형은 다음과 같다.   HRESULT CreateSurface(LPDDSURFACEDESC lpDDSurfaceDesc,
  LPDIRECTDRAWSURFACE FAR *lplpDDSurface, 
  IUnknown FAR *pUnkOuter);
 
첫 번째 인자인 lpDDSurfaceDesc는 만들고자  하는 면 객체의 특성을  기록
한 DDSURFACEDESC 구조체에 대한  포인터이다. 함수  호출이 성공했을  경
우 lplpDDSurface로는 생성된 다이렉트 드로우 면  객체의 포인터의 주소
가 들어온다. 마지막 인자인 pUnkOuter는 앞서 DirectDrawCreate에서 설명
한 것과 동일하다.   DDSURFACEDESC 구조체
이 구조체는 생성하고자 하는 면 객체의  특성을 담아두는데 사용된다. 만
들고자 하는 면 객체에 따라 사용되는 필드가 달라진다. 이 구조체의 필드 
수는 방대한데 이 중 별 의미 없는 것은 설명에서 제외하도록 하겠다.
DDSURFACEDESC 구조체 안에는 여러 개의 다른 구조체들이 포함되어 있다
(참고 1).  
DDCOLORKEY 구조체
컬러키를 기술하는데 사용되는 구조체이다.
■dwColorSpaceLowValue : 컬러키로 사용되는 컬러 값의 하위 더블 
워드 값.
■dwColorSpaceHighValue : 컬러키로 사용되는 컬러 값의 상위 더블 
워드 값.
DDSCAPS 구조체
DDSCAPS 구조체는 다이렉트 드로우 면 객체의  기능을 정의한다. 이 구조체
는 DDCAPS  구조체와 DDSURF ACEDESC 구조체의 일부로  존재한다(참고 
2). 
CreatePalette 함수
다이렉트 드로우 객체에서 사용될  다이렉트 드로우 팔레트  객체를 생성한
다. 
이 함수의 원형은 다음과 같다.
HRESULT CreatePalette(DWORD dwFlags, LPPALETTEENTRY 
  lpColorTable,   
LPDIRECTDRAWPALETTE FAR *lplpDDPalette, IUnknown FAR 
  *pUnkOuter);
첫 번째 인자인 dwFlags에는 표  4와 같은 값들이 하나 이상  올 수 있다. 
두 번째 인자인 lpColorTable은 다이렉트 드로우 팔레트  객체를 초기화하
는데 사용될 PALETTEENT RY 구조체를 가리킨다. 세 번째 인자인 
lplpDDPalette는 이 함수가 성공했을 경우에 리턴되는  다이렉트 드로우 팔
레트 객체의  주소를 담아올 포인터이다. 마지막 인자인 pUnkOuter는 앞에
서 봤던 것처럼 COM 포함(aggregation)에 사용되는 것으로 NULL을 준다.   다이렉트 드로우 면(DirectDrawSurface) 객체
Blt 함수이 함수는 기존 GDI의 StretchBlt와 비슷한 기능을 수행한다고 생
각하면 된다. 
한 면 객체에서 다른 면 객체의 블록 복사를 수행하는데 소스 복사 영역과 
대상 복사 영역의 크기가 일치하지 않을  경우 알아서 확대나 축소를 행
한  후에 복사 작업을   수행한다. 이  함수는  현재 Z-버퍼링이나   알파 
블렌딩(alpha blending)을 지원하지 않는다. 이 함수의 원형은 다음과 같
다.
HRESULT Blt(LPRECT lpDestRect, LPDIRECTDRAWSURFACE3 
   lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, 
   LPDDBLTFX lpDDBltFx);
 
첫 번째 인자인 lpDestRect는 대상 면 객체의 어디로 블록 복사가 이루어
질 것인지를 나타내는 RECT 구조체의 포인터이다.  만일 이 값이 NULL이
면  대상 면 객체의 전체 영역을 대상으로 한다.  여기서 주의할 점은 이 
RECT 구조체의 right와 bottom 필드의 값은 포함되지 않는다는 점이다. 이
는 세 번째 인자인 lpSrcRect의 경우에도 마찬가지이다. 두 번째  인자는 
소스 면 객체에 대한 포인터이다. 세 번째 인자인 lpSrcRect는 소스 면 객
체의 어느 영역을 대상 면 객체로 복사할 것인지를 나타내는 RECT  구조체
의 포인터이다. 만일 이 값이 NULL이면 소스 면 객체의 전체 영역을  대상
으로 한다. 네 번째 인자는 복사 작업을 어떻게 할 것인지를 나타내는 플래
그를 주는 부분으로 다음 값들을  하나 이상 주면 된다.
■DDBLT_COLORFILL  : 이 함수의 마지막 인자인 lpDDBltFx의 dwFillColor 
필드의 RGB 값을 이용해 대상 면의 대상 영역을 채운다.
■DDBLT_DDFX  : 이 함수의 마지막 인자인 lpDDBltFx의 dwDDFX 필드를 
이용해 복사 작업에 사용할 효과를 지정한다.
■DDBLT_DDROPS  : 이 함수의 마지막 인자인 lpDDBltFx의 dwDDROPS 
  필드를 이용해 래스터 작업을 지정한다. 여기서의 래스터 작업은 Win32 
  API에는 없던 것들이다.
■DDBLT_KEYDEST : 대상 면의 컬러키를 이용한다.
■DDBLT_KEYDESTOVERRIDE  : 이  함수의 마지막 인자인  lpDDBltFx의 
dckDestColorkey 필드로 대상 면의 컬러키를 대신한다.
■DDBLT_KEYSRC : 소스 면의 컬러 키를 이용한다.
■DDBLT_KEYSRCOVERRIDE  :  이 함수의  마지막 인자인   lpDDBltFx의 
dckSrcColorkey 필드로 소스 면의 컬러키를 대신한다.
■DDBLT_ROP : 이 함수의 마지막 인자인 lpDDBltFx의 dwROP 필드를 이용
해 래스터 작업을 지정한다. 여기서의 래스터 작업은 Win32  API에 있던 것
과 동일한 것이다.
■DDBLT_ROTATIONANGLE :   이 함수의   마지막 인자인   lpDDBltFx의 
dwRotationAngle 필드를 이용해 회전각을 지정한다. 회전각은 1/100도를  
단위로 지정된다.
■DDBLT_WAIT : 복사  작업이 대기로  인해 바로  이루어질 수 없는  경우
(DDERR_WASSTILLDRAWING가 리턴되는 경우) 기다렸다가 복사 작업이 완
료된 다음에 리턴하도록 한다. 만일 이 플래그를 지정하지 않는다면 대기 
등으로 인해 바로 작업을 완료할 수 없는 경우 아무 일도 수행하지 않고 바
로 리턴한다.
마지막 인자는 복사 작업과 관련된 DDBLTFX 구조체를 가리킨다.
BltFast 함수이 함수는 소스 컬러키나 목적 컬러키를 이용한 투명 복사나 
소스를 그대로 복사하는 작업을 수행해준다. 이  함수의 특징은 하드웨어에
서  지원 가능하다면 비동기 복사 작업을 수행하고 또  비디오 메모리 안에
서의 복사만이  가능하며 클리퍼를 적용할 수 없기 때문에  빠르다는 점이
며 1:1 복사만을 지원한다.  이 함수의 원형은 다음과 같다.
HRESULT BltFast(DWORD dwX, DWORD dwY, 
  LPDIRECTDRAWSURFACE3 lpDDSrcSurface, LPRECT lpSrcRect, 
  DWORD dwTrans);
 
dwX, dwY는  복사 작업이  시작될 대상   면의 시작 X,Y  좌표를 나타낸
다. lpDDSrcSurface는 복사 작업의 소스 면 객체의 포인터를  가리킨다. 
lpSrcRect는 소스 면 객체의 어느 부분을 복사할 것인지를 나타내는 RECT 
구조체의 포인터이다. 네 번째 인자인 dwTrans는 복사 작업을 어떻게 수행
할 것인지는 지정하는 부분으로 표 5와 같은 값이 가능하다.
===============================================================
DDBLTFAST_DESTCOLORKEY  대상 컬러키를   이용하는  투명   복사 작 
                        업을 수행한다.
DDBLTFAST_NOCOLORKEY    컬러키를  사용하지  않는  보통  복사  작 
                        업을 수행한다.
DDBLTFAST_SRCCOLORKEY   소스   컬러키를 이용하는   투명  복사  작 
                        업을 수행한다.
DDBLTFAST_WAIT          복사 작업이 대기로 인해 바로 이루어질  수 
                        없는경우(DDERR_WASSTILLDRAWING가 
                        리턴되는 경우) 기다렸다가 복사  작업이 완 
                        료된 다음에 리턴하도록 한다. 만일 이 플래
                        그를 지정하지 않는다면  대기 등으로  인해 
                        바로 작업을 완료할 수 없는 경우  아무일도 
                        수행하지 않고 바로 리턴한다.
===============================================================
표 5 : BltFast 함수에서 dwTrans에 올 수 있는 값들Flip 함수   이 함수는 DDSCAPS_BACKBUFFER로 지정된 후면  버퍼를 전면 버퍼의 내
용과 맞바꾸게 한다. 즉, 전면 버퍼가 이제 후면 버퍼가 되고 후면 버퍼가 
전면 버퍼가 되는   것이다. 이   함수는 DDSCAPS_FLIP과   
DDSCAPS_FRONTB UFFER 플래그로 만들어진 면에 대해서만 적용가능하며 이 
함수는 비디오  신호가 수직 주사 주기에 맞춰 동작한다. 이 함수의 원형
은 다음과 같다.
HRESULT Flip(LPDIRECTDRAWSURFACE3 lpDDSurfaceTarget
   Override, DWORD dwFlags);
첫 번째 인자인 lpDDSurfaceTargetOverride는 이 면  객체와 맞바꾸어질 대
상 면 객체의 주소를 지정한다. 지정된  면 객체는 플립핑 체인에  속한 것
이어야 한다. 이 인자의 디폴트 값은 NULL인  경우 플립핑 체인에 속한 다
음 버퍼와 내용을 맞바꾼다. 두 번째 인자인 dwFlags는  플립핑 작업이 어
떻게 이루어질 것인지를 지정한다. 표 6과 같은 값이 가능하다.
GetDC 함수면 객체의 DC를 생성해준다. 이 DC는 마치  보통 윈도 DC처럼 사
용할 수 있다. 이렇게 얻은 DC는  나중에 면 객체의  ReleaseDC 함수를 호
출해주어야만 해제된다. 이 함수의 원형은 다음과 같다. 
HRESULT GetDC(HDC FAR *lphDC);
첫 번째 인자인 lphDC는 리턴되는 디바이스 컨텍스트의 핸들을 받는데 사용
된다. 
DDFLIP_EVEN 오버레이   면에   있는  내용을   디스플레이하고자  할   때
만 사용된다. 새로운 면은 비디오 신호 중에 짝수  필드에 있는 데이터만 
포함한다. 이 값은 DDFLIP_ODD      와 함께 사용될 수 없다. 
DDFLIP_ODD   오버레이  면에   있는   내용을  디스플레이하고자   할  때
만 사용된다. 새로운 면은 비디오 신호 중에 홀수  필드에 있는 데이터만 
포함한다. 이 값은 DDFLIP_EVEN과 함께 사용될 수 없다.
DDFLIP_WAIT 만일   플립  작업을   수행하려  할   때  하드웨어의   상태
가 적합하지 못하면 DDERR_WASSTILLDRAWING        에러가 발
생하고 플립 작업은 수행될 수 없는데 이 플래그를 지정하면 가능한 상태
가 될 때까지 기다렸다가 플립 작업을 수행하고 리턴한다.   표 6 : Flip 함수에서 두 번째 인자인 dwFlags의 값들   GetAttachedSurface 함수
이 함수는 지정된 기능을 갖는 추가된 면의 포인터를 얻어준다. 원형은 다
음과 같다.
HRESULT GetAttachedSurface(LPDDSCAPS lpDDSCaps,  
   LPDIRECTDRAWSURFACE3 FAR *lplpDDAttachedSurface);
첫 번째 인자인 lpDDSCaps는 얻어오고자 하는  면 객체의 하드웨어적인 기
능을    담아두는   DDSCAPS    구조체를   가리킨다.    두   번째    인
자인 lplpDDAttachedSurface는 얻어올 다이렉트  드로우 면 객체의  주소
를 얻어올 포인터이다. 
Lock 함수면 객체의 내부 데이터를 보관하고 있는 메모리에 대한 포인터를 
얻어준다. 이 함수는 면 데이터를 직접 접근하고자  할 때 아주 유용하
다.  이렇게 포인터를 얻어 사용한  다음 반드시  Unlock 함수를  호출해
서  락을 풀어주어야  한다. 
Lock 함수의 원형은 다음과 같다.
HRESULT Lock(LPRECT lpDestRect, LPDDSURFACEDESC 
   lpDDSurfaceDesc, DWORD dwFlags, HANDLE hEvent);
첫 번째 인자인 lpDestRect는 면 객체의 어느 영역에 대한 포인터를 얻을 
것인지 결정한다. 만일 이  인자로 NULL을 지정하면  전체 영역에 대한 포
인터를 얻게 된다. 두 번째 인자인 lpDDSurfaceDesc는 DDSURFACEDESC 구조
체 타입을 갖게 되며 면에 대한 정보를 가져온다.  세 번째 인자인 dwFlags
로는 다음과 같은 값을 지정할 수 있다.
■DDLOCK_EVENT : 현재 구현되어 있지 않다.
■DDLOCK_READONLY : 읽기 전용으로 메모리의 내용을 락한다.
■DDLOCK_SURFACEMEMORYPTR : 지정한 사각 영역의 선두에 대한 포인
터가 리턴되어야함을 지정한다. 만일 이것이 지정되지  않으면 지정된 사
각 영역과는 관계없이 면 전체의 선두에 대한 포인터가 리턴된다.
■DDLOCK_WAIT : 만일 현재 복사 작업이 진행중이라면 락은 성공할 수 없
다. 이 플래그를 지정하면 기다렸다가 락을 건다.
■DDLOCK_WRITEONLY : 쓰기 전용으로 메모리의 내용을 락한다
마지막 인자인 hEvent는 현재 사용되지  않으며 반드시 NULL로 지정해야 한
다.   SetPalette 함수
이 함수는 지정된 다이렉트 드로우 팔레트 객체를 이 면 객체에 붙이는 역
할을 한다. 면 객체는 이후 작업에 이 팔레트 객체를 사용하게 된다. 팔레
트  객체의 추가로 인한 변경은 바로 반영된다. 현재 면 객체에서 사용중
인 팔레트의 내용을 알고 싶다면 GetPalette 함수를 호출한다. SetPalette 
함수의 원형은  다음과 같다.   HRESULT SetPalette(LPDIRECTDRAWPALETTE lpDDPalette);
lpDDPalette 인자는 면 객체가 이후 작업에 사용할 팔레트 객체의 주소를 
가리킨다.   참고로  팔레트   객체의  생성에는   다이렉트  드로우   
면   객체의 CreatePalette 함수를 이용한다.   SetColorKey 함수
이 함수는 다이렉트 드로우 면 객체의 컬러키를 지정해준다. 면에 대해 투
명한 복사 작업을 수행해야 한다면 이 함수의 사용은 필수적이다. 이 함수
의 원형은 다음과 같다.   HRESULT SetColorKey(DWORD dwFlags, LPDDCOLORKEY 
   lpDDColorKey);
첫 번째 인자인 dwFlags는 어떤 형태의 컬러키를 지정하는지 결정한다.
■DDCKEY_COLORSPACE  : 여러 개의  컬러키를 사용할 경우에 지정한다. 
여러 개의 컬러키가 사용될 경우 이를 컬러 스페이스라고 한다.
■DDCKEY_DESTBLT :  복사 작업시에 대상 컬러키로  사용할 컬러키나 컬
러 스페이스를 지정할 경우에 지정한다.
■DDCKEY_DESTOVERLAY : 오버레이 작업시에 대상  컬러키로 사용할 컬
러키나 컬러 스페이스를 지정할 경우에 지정한다.  
■DDCKEY_SRCBLT : 복사 작업시에  소스 컬러키로 사용할  컬러키나 컬러 
스페이스를 지정할 경우에 지정한다.
■DDCKEY_SRCOVERLAY : 오버레이 작업시에 소스 컬러키로  사용할 컬러
키나 컬러 스페이스를 지정할 경우에 지정한다.  
두 번째 인자인 lpDDColorKey는 다이렉트 드로우 면 객체의 새로운 컬러키
로 사용될 값을 포함하는 DDCOLORKEY 구조체를 가리킨다.   Restore 함수
이 함수는 유실되었던 면 객체의 내용을  복구해준다. 다이렉트 드로우에
서 사용하는 출력 관련 자원은 GDI와 공유되는  부분이 많다. 그런데 이로 
인해 가끔 다이렉트 드로우 면 객체의  내용이 깨지는 경우가 발생한다.  
그런 경우에 바로 이 함수를 호출해주어야 하며  면 객체의 내용이 유실되
었는지의  여부는 IsLost 함수를 호출해보면 알 수 있다. 
또  다른  방법으로  다이렉트  드로우   면 객체   관련 함수들의   리턴
값이 DDERR_SURFACELOST인지를 살펴보는 것이다. 그런데  중요한 것은 이 
함수는 메모리 영역을 다시 잡아줄 뿐이지 유실 이전에 들어있던 내용까
지  복구해주지 못한다. 따라서 어떻게 내용을 복구할 것인지는 개발자의 
책임이다.  이 함수의 원형은 다음과 같다.   HRESULT Restore();
다이렉트 드로우 팔레트(DirectDrawPalette) 객체
다이렉트 드로우 객체의 CreatePalette 함수를  통해 생성가능하며 모두 4
개의 간단한 함수들을 구성된다. 이 중에서 GetCaps와 GetEntries에  대해
서만 알아보자.   GetCaps 함수
이 함수는 팔레트 객체의 기능을 알아보는데 사용된다. 이 함수의 원형은 
다음과 같다.
HRESULT GetCaps(LPDWORD lpdwCaps);
 lpdwCaps 인자로는  팔레트의 구성을   나타내는 값이 들어오는데   이 값
은 DDCAPS 구조체의 dwPalCaps 필드의 값과 동일하다. 다음과 같은 값이 가
능하다.
DDPCAPS_1BIT, DDPCAPS_2BIT, DDPCAPS_4BIT, DDPCAPS_8BIT,
DDPCAPS_8BITENTRIES, DDPCAPS_ALLOW256, DDPCAPS_PRIMARY
SURFACE, DDPCAPS_PRIMARYSURFACELEFT, DDPCAPS_VSYNC   GetEntries 함수
다이렉트 드로우 팔레트  객체에서 팔레트 값을  얻어온다. GetEntries 함
수의 원형은 다음과 같다.
HRESULT GetEntries(DWORD dwFlags, DWORD dwBase, DWORD 
dwNumEntries, LPPALETTEENTRY lpEntries);
dwFlags 인자는 현재 사용되지 않으며 0을 지정해야 한다. dwBase 인자는 
얻고자 하는 항목의 시작 번호를 가리킨다. dwNumEntries 인자는 dwBase 항
목서부터 모두 몇 개의 항목을 읽어가려 하는지 그  수를 지정한다. 
lpEntries 인자는   이런   팔레트   항목의   값을   받아갈   버퍼를   
가리킨다.    만일 DDPCAPS_8BITENTRIES 플래그가 설정된  팔레트라면 각 
항목의  크기는 1 바이트가 되고 나머지 경우에는 4바이트가 된다.   - 계속 -
 
- the end of this article -

 less.. 

less..

 

다이렉트 사운드 실전 프로그래밍

게임에 있어 중요한 것 중의 하나가 바로 음향 효과이다. 요즘은 게임마

다 음향 효과의 중요도 한층 더 배가되는 분위기이다. 사실적인 음향으로

인해 게임에 한층 더 몰입할 수 있는 것은 물론이고 돈 좀 들었을 것 같

은 배경 음악이 계속적으로 들려나오기도 한다. 다이렉트X의 로우레벨 서

비스인 다이렉트 파운데이션의 일부로 존재하는 다이렉트 사운드에서 바

로 이런 기능을 여러분의 프로그램에 쉽게 추가할 수 있도록 해준다.

다이렉트 사운드 실전 프로그래밍

다이렉트 사운드란 ?

다이렉트 사운드는 디지털 사운드를 플레이하고 캡처하고 이들을 믹싱할

수 있는 기능을 제공해준다. 다른 다이렉트X 컴포넌트들과 마찬가지로 이

역시 하드웨어를 가능한한 최대로 이용하고 할 수 없는 경우에만 소프트웨

어를 이용한다. 다이렉트 사운드 객체는 시스템 상의 오디오 하드웨어를

나타낸다. 이 객체를 이용해 사운드 카드, 스피커와 관련 메모리 환경을 제

어할 수 있다. 현재까지 다이렉트 사운드는 압축된 형식의 사운드 데이

터는 지원하지 못한다.

즉, 예를 들어 .WAV 형식의 파일을 다이렉트 사운드를 통해 연주하려면

그 파일의 데이터가 압축되어 있을 경우 압축을 풀어서 연주해야 한다. 다

이렉트 사운드의 구조는 그림 10과 같다.

그림 10 : 다이렉트 사운드 시스템의 구조

다이렉트 사운드 관련 객체

다이렉트 사운드 객체는 플레이와 캡처별로 별도의 자식 객체를 운영한

다. 다이렉트 사운드 관련 객체로는 다음과 같은 것이 있다.

- 다이렉트 사운드 객체

- 다이렉트 사운드 버퍼 객체

- 다이렉트 3D 사운드 버퍼 객체

- 다이렉트 캡처 객체

다이렉트 드로우에서처럼 중심이 되는 객체는 다이렉트 사운드 객체이

다. 이 객체를 통해 다른 객체들을 생성하게 된다. 어떤 음향을 출력하려

면 다이렉트 사운드 버퍼 객체나 3D 사운드 버퍼 객체를 생성해야 한다. 만

일 어떤 음향을 녹음하고자 한다면 다이렉트 캡처 객체를 이용한다.

다이렉트 사운드 프로그램 작성

만들고자 하는 다이렉트 사운드 예제 프로그램의 기능은 간단하다. 파일

메뉴의 열기 명령을 통해 .WAV 파일을 로드한 다음 연주 명령을 택하

면 .WAV 파일의 연주를 시작하고 중지 명령을 택하면 연주를 중단한다.

예제 프로그램의 시작

다이렉트 드로우를 사용하려면 제일 먼저 해야할 일은 dsound.h라는 헤더

파일을 포함하고 dsound.lib와 winmm.lib라는 라이브러리 파일을 링크시

라이브러리 항목으로 지정하는 일이다. 앞서 Project의 Settings 명령을

이용해 라이브러리 파일을 지정하는 예는 설명하였다. 이 예제 프로그램 역

시 API를 이용해 작성할 것이다. 이 프로그램은 보통의 윈도 프로그램

과 동일한 형태의 WinMain을 갖는다. WinMain에 대한 설명은 생략하기로

하겠다.

다이렉트 사운드 객체의 초기화

일단 다이렉트 사운드 객체를 대표하는 전역 변수를 하나 선언한다.

// DirectSound 관련 변수
LPDIRECTSOUND pDirectSoundObj; // DirectSound 객체

다이렉트 사운드 객체의 초기화는 WM_CREATE 메시지부에서 수행한다.

switch (message)
{
// 변수를 초기화한다.
case WM_CREATE:
{
     pDirectSoundObj = NULL;
     // 다이렉트 사운드 객체를 일단 NULL로
     pDirectSoundBuffer = NULL;
     // 다이렉트 사운드 버퍼 객체를 일단 NULL로
     // ----------------------------------
     // DirectSound 관련 초기화를 수행한다.
     // ----------------------------------
     if (DirectSoundCreate(NULL, &pDirectSoundObj, NULL) != DS_OK)
          return -1;
     // 우선순위 레벨을 정한다.
     if (pDirectSoundObj->SetCooperativeLevel(hWnd, DSSCL_NORMAL) != DS_OK)
          return -1;
          return 0;
     }

다이렉트 사운드에는 다이렉트 사운드 객체의 생성을 위해서

DirectSoundCreate라는 별도의 도우미 함수를 제공해준다. 이를 이용해 다

이렉트 사운드 객체를 생성한다. 이 함수 및 이후에 나오는 다이렉트 사운

드 관련 함수의 자세한 기능에 대해서는 뒤에 있는 다이렉트 사운드 레퍼런

스를 참고하기 바란다.

만일 DirectSoundCreate와 같은 도우미 함수를 이용하지 않는다면

CreateInstance와 같은 COM API를 이용하여 약간은 복잡하게 객체를 생성

해야 한다. 다이렉트 사운드 객체의 생성이 끝나면 이것의 협동 레벨을

설정해야 한다. 사운드 장치라는 것이 혼자서만 독점할 수 있는 것이 아니

다. 왜냐면 윈도 운영체계는 멀티태스크 환경이기 때문에 여러 프로그램에

서 사운드 디바이스를 사용하려 할 수 있다. 그렇기 때문에 협동 레벨을 지

정하여 남들과의 공존을 꾀하거나 독점을 시도할 수도 있다. 여기서

는 두 번째 인자로 DSSCL_NORMAL을 주어 공존을 꾀하고 있다. 이렇

게 DSSCL_NORMAL을 주면 사운드 카드를 통한 출력이 22KHz의 8비트 샘플

데이터와 스테레오 사운드로 고정된다는 점도 같이 알아두기 바란다.

이렇게 하나로 고정시켜야 여러 프로그램에서 공용하기가 쉽기 때문이다.

협동 레벨에는‘정상(normal)’,‘우선(priority)’,‘독점(exclusive)’,

‘쓰기우선(write primary)’이 있다. 대부분의 경우 특별한 이유가 없다

면 ‘정상’을 사용한다.

다이렉트 사운드 버퍼 객체의 생성

다이렉트 사운드를 이용해 사운드 출력을 행하려면 버퍼 객체를 별도로 생

성해 주어야 한다. 이러한 개념은 다이렉트 드로우에서와 비슷한 면이 있

다. 다만 다이렉트 드로우에서는 전위 버퍼와 후위 버퍼를 명시적으로 생성

해주어야 했지만 다이렉트 사운드에서는 주 사운드 버퍼(Primary sound

buffer)는 명시적으로 생성할 필요가 없고 다만 이차 사운드 버퍼만 명시

적으로 생성하면 된다.

그래서 이차 사운드 버퍼에 사운드 데이터를 써넣고 Play 명령을 주면 중

지 명령이 들어갈 때까지 다이렉트 사운드는 그 데이터를 계속적으로 연주

한다.

물론 한 번만 연주하고 끝내도록 할 수도 있고 직접 주 사운드 버퍼를 제어

할 수도 있는데 후자의 방법은 그다지 좋은 방법은 아닌 듯 하다.

다이렉트 사운드를 초기화하면 다이렉트 사운드는 내부적으로 주 사운드

버퍼를 생성하여 소리를 합성하고 출력장치로 내보내는데 사용한다. 각

사운드를 출력하려면 각기 이차 버퍼를 만들어 사용해야 한다. 사운드 믹싱

은 이차 버퍼에 있는 사운드를 동시에 출력하여 이뤄진다. 다이렉트 사운

드 믹서의 지연 시간은 20ms 정도이지만 이를 소프트웨어로 애뮬레이트

할 경우는 100~150ms 정도의 지연 시간이 발생한다.

이차 사운드 버퍼를 생성할 때는 이것이 스태틱 사운드 버퍼인지 아니면

스트리밍 사운드 버퍼인지를 명시해야 한다. 스태틱 사운드 버퍼는 메모리

에 사운드를 모두 보관한다. 스트리밍 사운드 버퍼는 사운드의 일부만 유지

한다. 스트리밍 버퍼를 사용할 때는 응용프로그램에서 주기적으로 새로운

데이터를 버퍼에 써넣어야 한다.

만일 사운드 데이터를 모두 메모리에 올려놓고 연주하려 한다면 버퍼 관리

에는 거의 신경쓸 일이 없다. 하지만 이는 작은 크기의 사운드 파일에만

가능한 일이다. 큰 파일의 경우에는 보다 더 메모리를 효율적으로 써야

한다. 큰 파일이 아니더라도 여러 개의 사운드 파일을 동시에 연주할 경우

에도 마찬가지이다. 스트리밍(streaming)이 바로 작은 버퍼를 통해 커다란

파일을 연주하는 방법이다. 즉 메모리는 조금만 할당해놓고 계속적으로

사운드 파일의 다음 데이터를 읽어다가 채우는 방식을 택하는 것이다.

이 방법은 효율적이긴 하지만 연주되는 속도가 채워지는 속도보다 빠를 경

우 문제가 된다. 즉, 지연이 발생하여 듣는 사람 입장에서는 끊기는 듯한

느낌이나 잡음이 들릴 수가 있다.

이 방법의 관건은 바로 버퍼가 비워지기 전에 채워넣는 적합한 시점을 어

떻게 찾아내느냐에 달려있다. 여기에는 다음과 같은 방법이 있다.

- 타이머 메시지 등을 이용해 주기적으로 검사한다.

- 버퍼의 특정 위치가 연주되면 이벤트를 발생시키도록 한다.

예제 프로그램에서는 간단하게 스태틱 사운드 버퍼를 사용해 사운드 파일

데이터를 모두 메모리에 올려놓고 한 번에 연주해보도록 하겠다. 다음과 같

은 변수를 전역 변수로 정의한다.

LPDIRECTSOUNDBUFFER pDirectSoundBuffer;
// 사운드 버퍼 객체
// WAVE 파일 관련 변수
DWORD waveSize;
BOOL waveOK;
char *pWave;
WAVEFORMATEX waveFormatEx;

먼저 사용자가 파일 메뉴의 열기 명령을 택하면 리스트 11의 코드가 실행된

다.

===============================================================
리스트 11 : 파일 메뉴의 열기 명령을 택하면 실행되는 코드
---------------------------------------------------------------
case WM_COMMAND :
{
     switch(LOWORD(wParam))
     {

case ID_OPEN :

{

OPENFILENAME ofn;

char buffer[MAXCHARS];

buffer[0] = 0;

memset(&ofn, 0x00, sizeof

(OPENFILENAME));

ofn.lStructSize = sizeof(OPENFILENAME);

ofn.hwndOwner = hWnd;

ofn.lpstrFilter = "Wave Files\

000*.wav\000\000";

ofn.nFilterIndex = 1;

ofn.lpstrFile = buffer;

ofn.nMaxFile = MAXCHARS;

// 파일 오픈 다이알로그를 띄운다.

if (GetOpenFileName(&ofn))

{

if (!Load(buffer, TRUE))

// 지정된 Wave 파일을 로드한다.

{

MessageBox(hWnd, "Wave 파일이

아닙니다.", "에러", MB_OK);

}

}

break;

}

}

}

===============================================================

리스트 11은 파일 오픈 다이얼로그 박스를 실행시켜 사용자로부터 .WAV

파일을 입력받는것이다. 사용자가 파일의 입력을 끝내고 OK 버튼을 누르면

Load 함수를 실행시켜 이차 사운드 버퍼를 생성하고 거기로 WAV 파일의 모

든 내용을 올려버린다. Load 파일은 다음과 같다.

// ----------------------------------------------------

// Load : 지정한 파일을 로드하여 이차 버퍼를 만들고 거기에

// 사운드 데이터를 로드한다.

// ----------------------------------------------------

BOOL Load(LPCSTR pWavFileName, BOOL bAll)

{

// 이차 버퍼를 생성한다.

if (!CreateBuffer(pWavFileName, bAll))

return FALSE;

// 사운드 데이터를 로드한다.

return LoadSoundData(bAll, (bAll) ? 0 : cbBufSize);

}

위의 함수에서는 이차 사운드 버퍼를 생성하기 위해 CreateBuffer라는 함

수를 이용하고 있다. 그리고 사운드 데이터를 로드하기 위해

LoadSoundData라는 함수를 호출하고 있다. 이 두 함수의 내용은 리스트

12, 13, 14와 같다.

CreateBuffer 함수를 보면 WAV 파일 데이터를 로드하기 위해 LoadWave

FileToPCM이란 함수를 호출한다. 이 함수는 WAV 파일의 압축 데이터를 다

이렉트 사운드에서 사용할 수 있도록 풀어주는 역할을 담당한다. 그러

기 위해서 윈도의 mmIO 라이브러리를 사용하는데 그 내용이 꽤 까다롭

다. 필자도 그 내용을 이해한 것은 아니고 웹사이트에서 남들이 만들어 놓

은 것을 가져다 썼다. LoadWaveFileToPCM 함수에서는 일단 WAV 파일의 데

이터를 pWave가 가리키는 메모리로 올려놓고 그 크기를 waveSize 변수에 저

장해둔다.

===============================================================

리스트 12 : CreateBuffer 함수

// ----------------------------------------------

// CreateBuffer : 지정된 파일을 읽어들여 DirectSound

// 이차 버퍼를 만든다.

// ----------------------------------------------

BOOL CreateBuffer(LPCSTR sndFileName, BOOL bAll)

{

DSBUFFERDESC dsBufferDesc;

// WAV 파일을 로드한다.

if (LoadWaveFileToPCM((LPSTR)sndFileName)

== FALSE)

return FALSE;

// DSBUFFERDESC 구조체를 초기화한다.

memset(&dsBufferDesc, 0, sizeof

(DSBUFFERDESC));

dsBufferDesc.dwSize = sizeof(DSBUFFERDESC);

dsBufferDesc.dwFlags = DSBCAPS_CTRLDEFAULT;

if (bAll)

dsBufferDesc.dwBufferBytes = waveSize;

else

{

cbBufSize = 2000;

dsBufferDesc.dwBufferBytes = waveSize;

}

dsBufferDesc.lpwfxFormat

= (LPWAVEFORMATEX)&waveFormatEx;

// 앞서 생성된 이차 버퍼가 있으면 이를 먼저 해제한다.

if (pDirectSoundBuffer)

pDirectSoundBuffer->Release();

// 이차 버퍼를 생성한다.

if (pDirectSoundObj->CreateSoundBuffer

(&dsBufferDesc, &pDirectSoundBuffer, NULL)

!= DS_OK)

return FALSE;

return TRUE;

}

===============================================================

다음으로 DSBUFFERDESC 구조체의 dsBufferDesc 변수를 초기화하고 이차

사운드 버퍼를 생성하기위해 다이렉트 사운드 객체의 CreateSoundBuffer 함

수

를 호출하여 그 값을 pDirectSoundBuffer 변수에 저장해둔다.

LoadWaveFile

ToPCM 함수의 원형은 리스트 13과 같다.

===============================================================

리스트 13 : LoadWaveFileToPCM 함수

// ----------------------------------------------

// LoadWaveFileToPCM : 지정된 파일을 읽어들여 이를

// 버퍼로 읽어들인다.

// ----------------------------------------------

BOOL LoadWaveFileToPCM(char* fileName)

{

MMCKINFO mmCkInfoRIFF;

MMCKINFO mmCkInfoChunk;

HMMIO hMMIO;

// Open the wave file.

hMMIO = mmioOpen(fileName, NULL, MMIO_READ

| MMIO_ALLOCBUF);

if (hMMIO == NULL)

return FALSE;

// Descend into the RIFF chunk.

mmCkInfoRIFF.fccType = mmioFOURCC

('W', 'A', 'V', 'E');

if (mmioDescend(hMMIO, &mmCkInfoRIFF,

NULL, MMIO_FINDRIFF) !

= MMSYSERR_NOERROR)

return FALSE;

// Descend into the format chunk.

mmCkInfoChunk.ckid = mmioFOURCC

('f', 'm', 't', ' ');

if (mmioDescend(hMMIO, &mmCkInfoChunk,

&mmCkInfoRIFF, MMIO_FINDCHUNK)

!= MMSYSERR_NOERROR)

return FALSE;

// Read the format information into the

WAVEFORMATEX structure.

if (mmioRead(hMMIO, (char*)&waveFormatEx,

sizeof(WAVEFORMATEX)) == -1)

return FALSE;

// Ascend out of the format chunk.

if (mmioAscend(hMMIO, &mmCkInfoChunk, 0)

!= MMSYSERR_NOERROR)

return FALSE;

// Descend into the data chunk.

mmCkInfoChunk.ckid = mmioFOURCC

('d', 'a', 't', 'a');

if (mmioDescend(hMMIO, &mmCkInfoChunk,

&mmCkInfoRIFF, MMIO_FINDCHUNK)

!= MMSYSERR_NOERROR)

return FALSE;

// WAV 데이터의 크기를 저장해둔다.

waveSize = mmCkInfoChunk.cksize;

// WAV 데이터를 저장해둘 메모리 영역을 확보해둔다.

pWave = (char*)GlobalAllocPtr

(GMEM_MOVEABLE, waveSize);

if (pWave == NULL)

return FALSE;

// WAV 데이터를 로드한다.

if (mmioRead(hMMIO, (char*)pWave, waveSize)

== -1)

return FALSE;

mmioClose(hMMIO, 0);

return TRUE;

}

===============================================================

이렇게 이차 사운드 버퍼가 생성되고 연주하고자 하는 WAV 파일의 내용

을 메모리로 읽어들여 놓았으면 WAV 파일의 내용을 이차 사운드 버퍼로 복

사해두어야 한다. 그 역할을 하는 것이 바로 LoadSoundData 함수이다.

WAV 데이터를 이차 사운드 버퍼로 써넣으려면 이차 사운드 버퍼의 포인터

를 얻어야 한다. 그 용도로 사용되는 것이 바로 다이렉트 사운드 버퍼

객체의 Lock 함수이고 사용한 다음에는 반드시 Unlock 함수를 호출하여 사

용이 끝났음을 알려야 한다. Lock 함수를 보면 이상하게도 포인터를 하나

가 아닌 두 개를 받도록 되어 있다. 이는 이차사운드 버퍼를 스트리밍

방식으로 사용할 때만 필요한 것이다. 예제 프로그램에서는 스태틱 방식으

로 모두 메모리에 올려놓고 사용하기 때문에 두 개의 포인터 중에서 앞의

것 하나만 필요하다.

사운드의 연주와 중지 이렇게 사운드 데이터의 이차 사운드 버퍼의 생성

이 종료되었으면 이제 연주하고 중지할 준비가 끝난 것이다.

연주 메뉴의 전체 연주 명령을 택하면 다음의 명령이 실행된다.

// --------------------------------------------------

// Play : 이차 버퍼에 쓰여진 데이터를 연주한다.

// --------------------------------------------------

BOOL Play(BOOL bInfiniteLoop)

{

if (pDirectSoundBuffer)

{

pDirectSoundBuffer->SetCurrentPosition(0);

pDirectSoundBuffer->Play(0, 0, DSBPLAY_LOOPING);

return TRUE;

}

return FALSE;

}

일단 이차 사운드 버퍼의 시작 연주 위치를 처음으로 되돌

리고(SetCurrentPosition(0)) 연주를 시작(Play)한다. 세 번째 인자로

DSBPLAY_LOOPING을 주었기 때문에 연주가 반복된다. 이 연주를 중지하고 싶

다면 중지 명령을 택한다. 이차 사운드 버퍼 객체의 Stop 함수를 호출하

면 현재 진행 중이던 연주가 중단된다. 중지 명령을 택하면 다음 함수가 실

행된다.

// ---------------------------------------------------

// Stop : 사운드 데이터의 연주를 중단한다.

// ---------------------------------------------------

BOOL Stop()

{ if (pDirectSoundBuffer)

return (pDirectSoundBuffer->Stop()==DS_OK)

? TRUE : FALSE;

else

return FALSE;

}

이것으로 다이렉트 사운드 프로그래밍에 대해 간단히 살펴보았다. 사실

스트리밍을 이용한 예제까지도 살펴봐야 제대로 된 다이렉트 사운드 프로

그래밍을 했다고 할 수 있을 텐데 다음 기회에 꼭 보여드릴 것을 약속한다.

다이렉트 사운드 레퍼런스

다이렉트 사운드 객체

DirectSoundCreate 함수

이 함수는 다이렉트 사운드 객체를 생성하고 초기화하는 역할을 담당한

다.

원형은 다음과 같다.

HRESULT WINAPI DirectSoundCreate(LPGUID lpGuid, LPDIRECT

SOUND * ppDS, IUnknown FAR * pUnkOuter);

첫 번째 인자인 lpGuid로는 생성하고자 하는 사운드 장치를 가리키는 GUID

를 지정해야 한다. 만일 디폴트 사운드 디바이스를 사용하려면 NULL을 지

정하면 된다. 두 번째 인자인 ppDS로는 결과적으로 생성되는 DirectSound

객체의 포인터를 받아오는 곳이다. 세 번째 인자는 현재로는 NULL을 주어

야 한다. 이 함수가 성공하면 DS_OK가 리턴된다. DirectSoundCreate로

DirectSound 객체의 생성이 성공하면 바로 SetCooperativeLevel 메소드를

호출해야 한다.

CreateSoundBuffer 함수

CreateSoundBuffer 메소드는 오디오 샘플 데이터를 저장하는데 사용되는

다이렉트 사운드 버퍼 객체를 생성한다. 이 함수의 원형은 다음과 같다.

HRESULT CreateSoundBuffer(LPCDSBUFFERDESC

lpcDSBufferDesc, LPLPDIRECTSOUNDBUFFER

lplpDirectSoundBuffer, IUnknown FAR * pUnkOuter);

첫 번째 인자인 lpcDSBufferDesc은 생성하고자 하는 사운드 버퍼의 형태를

기술한 DSBUFFERDESC 구조체를 인자로 받는다. 출력될 오디오 데이터의 형

식과 크기와 기능 등을 기술한다. 예를 들어 다이렉트 사운드 버퍼 객

체의 SetFrequency 함수를 사용하고 싶다면 이 구조체의 dwFlags

필드에 DSBCAPS_CTRLFREQUENCY를 지정해주어야 한다.

두 번째 인자인 lplpDirectSoundBuffer는 생성된 Direc tSoundBuffer 객체

의 주소를 받는다.

마지막 인자는 항상 NULL이어야 한다. 이 함수가 성공적으로 끝나면 리턴

값은 DS_OK가 된다.

DSBUFFERDESC 구조체

이 구조체는 생성하고자 하는 DirectSoundBuffer 객체의 특성을 기술하는

데 사용된다. 이 구조체는 앞에서 본 CreateSoundBuffer 메소드에 의해 사

용된다.

이 구조체의 각 필드의 구성은 다음과 같다.

LPWAVEFORMATEX lpwfxFormat;

DWORD dwSize : 이 구조체의 크기를 바이트 단위로 나타낸다.

DWORD dwFlags : 이 필드는 생성되는 DirectSoundBuffer의 기능을 지정하

는데 사용된다. 표 7과 같은 값을 하나 이상 지정할 수 있다.

DWORD dwBufferBytes : 버퍼의 크기를 바이트 단위로 지정한다.

주 버퍼를 생성할 때는 0을 지정해야 한다. 이 차 버퍼의 경우에는

DSBSIZE_

MIN와 DSBSIZE_MAX사이의 크기를 지정해야한다.

DWORD dwReserved : 사용되지 않는다.

LPWAVEFORMATEX lpwfxFormat

버퍼에서 사용할 사운드 데이터의 파형을 지정한다. 주버퍼의 경우에는

NULL을 지정해야 한다. 주 버퍼의 사운드 형식은 SetFormat 메소드를 이

용해 지정할 수 있다.

SetCooperativeLevel 함수

SetCooperativeLevel 메소드는 응용프로그램에서 사운드 디바이스를 어

떻게 사용할 것인지 협동 레벨을 지정한다. 이 함수의 원형은 다음과 같다.

HRESULT SetCooperativeLevel(HWND hwnd, DWORD dwLevel);

첫 번째 인자로는 이 응용프로그램의 윈도 핸들을 지정한다. 두 번째 인자

로는 원하는 우선 순위 레벨을 지정한다. 다음 값 중의 하나를 지정해야 한

다.

■DSSCL_EXCLUSIVE : 배타적 독점 레벨을 지정한다. 이 프로그램이 포커스

를 갖고 있을 때 이 프로그램이 단 하나의 사운드 소스가 된다. 이 레

벨은 DSSCL_PRIORITY 레벨의 모든 특권을 다 포함한다.

■DSSCL_NORMAL : 응용프로그램을 공동작업 상태로 만든다. 대부분의 프

로그램은 별다른 이유가 없는 한 이 모드를 사용해야 한다.

■DSSCL_PRIORITY : 이 모드의 프로그램은 버퍼의 형식을 변경(SetFormat

함수 호출 가능)할 수 있고 메모리를 온보드 메모리의 사용되지 않는 영

역을 이동(Compact 메소드 호출 가능)시킬 수 있다.

■DSSCL_WRITEPRIMARY : 가장 우선순위가 높은 레벨이다. 주 버퍼에 바

로 쓰는 것이 가능하며 이차 버퍼는 필요없다.

다이렉트 사운드 버퍼 객체

Play 함수

Play 메소드는 사운드 버퍼의 현재 위치부터 연주하도록 한다. 이 함수의

원형은 다음과 같다.

HRESULT Play(DWORD dwReserved1, DWORD dwReserved2,

DWORD dwFlags);

첫 번째 인자와 두 번째 인자는 0이어야 한다. 세 번째 인자인 dwFlags

는 버퍼를 어떻게 연주할 것인지를 나타내는 플래그이다. DSBPLAY_LOOPING

을 주면 연주가 명시적으로 중지될 때까지 연주가 계속적으로 반복된다.

Stop 함수

Stop 함수는 사운드 버퍼의 연주를 중지한다. 마지막으로 연주했던 곳

에서 멈추기 때문에 다시 Play 함수를 호출하면 멈췄던 부분에서부터 연주

가 다시 시작된다. 원형은 다음과 같다.

HRESULT Stop();

SetCurrentPosition 함수

SetCurrentPosition 함수는 버퍼(이차 버퍼만 가능)의 현재 연주 위치를

이동시킨다. 이 함수의 원형은 다음과 같다.

HRESULT SetCurrentPosition(DWORD dwNewPosition);

인자인 dwNewPosition으로는 버퍼의 새로운 위치를 나타내는 숫자를 지정

한다.

Lock 함수

Lock 함수는 버퍼의 유효한 쓰기 포인터를 얻어준다. 이 함수의 원형은 다

음과 같다.

HRESULT Lock(DWORD dwWriteCursor, DWORD dwWriteBytes,

LPVOID lplpvAudioPtr1, LPDWORD lpdwAudioBytes1,

LPVOID lplpvAudioPtr2, LPDWORD lpdwAudioBytes2,

DWORD dwFlags);

dwWriteCursor 인자는 버퍼의 어디서부터 락을 시작할 것인지를 지정한

다. 만일 dwFlags 인자에 DSBLOC K_FRO MWRITECURSOR가 지정되어

있다면 이 인자는 무시된다. dwWriteBytes 인자는 버퍼에서 어느 정도의 크

기를 락하려고 하는지 지정하는데 사용된다. lplpvAudioPtr1 인자는 버퍼

의 뒤 영역 중 락 된 영역에 대한 포인터를 얻어온다.

lpdwAudioBytes1는 lplpvAud ioPtr1가 가리키는 영역에서 몇 바이트가 락

되었는지를 나타내는 인자이다. 만일 이 인자의 값이 dwWriteBytes 인자

의 값보다 적다면 lplpvAudioPtr2 인자가 사운드 데이터의 두 번째 블록

을 가리킬 것이다. lplpvAudioPtr2는 두 번째 블록의 락된 주소를 받아온

다. 만일 첫 번째 블록으로 필요한 영역을 모두 락한 경우에는 이 인자의

값이 NULL이 된다. lpdwAudioBytes2는 lplpvAudioPtr2가 가리키는 주소에

서 몇 바이트가 락되었는지를 가리킨다. lplpvAudioPtr2가 NULL이면 이 인

자의 값은 0이 된다.

dwFlags 인자는 다음과 같은 값이 가능하다.

■DSBLOCK_FROMWRITECURSOR : 현재의 쓰기 위치부터 락을 건다. 이

인자를 주면 GetCurrentPosition 함수를 호출할 필요가 없으며

dwWriteCursor

인자가 무시된다.

■DSBLOCK_ENTIREBUFFER : 전체 버퍼를 락한다. dwWriteBytes 인자도

무시된다. 이렇게 락한 버퍼에 대한 포인터는 반드시 다이렉트 사운드 버

퍼의 Unlock 함수를 호출하여 반환해야 한다. 락되어있는 시간은 되도록 최

소화해야 한다.

Unlock 함수

이 함수는 락된 사운드 버퍼를 풀어주는 역할을 한다. 이 함수의 원형은

다음과 같다.

HRESULT Unlock(LPVOID lpvAudioPtr1, DWORD dwAudioBytes1,

LPVOID lpvAudioPtr2, DWORD dwAudioBytes2);

이 함수의 인자들의 값은 앞서 Lock함수의 세 번째 인자부터 여섯 번째

인자까지의 값과 동일하다. 간단하게나마 다이렉트X의 극히 일부에 해당하

는 다이렉트 사운드와 드로우에 대해 알아보았다. 예제 프로그램 중심으

로 살펴보았기 때문에 이해에 큰 무리는 없었으리라 생각된다. 물론 API

에 대한 프로그래밍 경험이 없거나 익숙하지 못한 독자들은 어려운 점이

많았으리라 생각된다. 한 입에 배부를 수는 없는 일이다. API를 이용한

프로그래밍은 윈도 프로그래밍의 기본이다. API 프로그래밍부터 공부한 사

람은 어떤 타입의 윈도 프로그래밍이든지 간에 뼈속 깊이까지 이해할 수

있다. 이제 천고마비의 계절 가을이다. 선선한 날씨에 공부 열심히 하기

바라며 필자의 글이 여러분의 다이렉트X에 대한 궁금증 중 일부를 풀어주

었기를 기대한다. 다이렉트 드로우와 사운드를 이용한 게임 제작은 다음

기회에 설명하도록 하겠다. 그 때까지 독자 여러분들도 열심히 공부하기

바란다.

다이렉트 뮤직의 등장

필자가 원고를 거의 다 마무리해갈 즈음해서 마이크로소프트의 다이렉트X

사이트에 들어갔다가 다이렉트X에 새로운 컴포넌트인 다이렉

트 뮤직(DirectMusic)이 추가되었다는 것을 알게 되었다.

현재까지 다이렉트X는 주로 그래픽이나 애니메이션과 사운드 기능의 향상

에 중점을 두어온 것이 사실이다. 사운드의 경우 3D 사운드까지 지원되기

는 하지만 기능 자체가 멀티미디어 프로그램에 충분하다고 볼 수는 없었

다.

이 컴포넌트는 MIDI에 기반하여 동작하기 때문에 기존의 다이렉트 사운드와

는 다른 차원의 서비스를 제공해준다. MIDI 프로토콜이 처음 등장한 것

은 바로 1982년이었다. 이것의 등장으로 인해 전자 악기와 컴퓨터간의 연결

이 가능해졌고 이것으로 인해 집에서도 음악을 만드는 것이 가능해졌다.

이러한 MIDI의 기반 위에 만들어진 다이렉트 뮤직은 산업계의 표준이

라 할 수 있는 DLS(Downloadable sound)를 완벽하게 지원한다는 특징

도 갖고 있다. 따라서 사운드카드 등의 실제 연주 장치에 따라 음질이 달라

지는 문제를 해결할 수 있는 실마리를 제공한다. 다이렉트 뮤직에 관한

자세한 사항은 http://www.microsoft.com/directx에서 찾아볼 수 있다.

델파이에서 다이렉트X 사용하기 필자가 예로 든 예제 프로그램들은 모두

API를 이용해 작성되어있다. 사실 델파이에서는 윈도 API를 아무런 무리 없

이 다 호출할 수 있기 때문에(VB는 포인터라는 개념이 없기 때문에 모든

API를 다 부를 수는 없다) 예제 프로그램의 코드를 델파이에서 사용할

수 있다. 다만 모양이 별로 델파이답지는 못할 것이다. 다이렉트X를 하나

의 컨트롤처럼 쉽게 사용할 수 있도록 해주려는 시도가 여러 곳에서 진행되

고 있다. 델파이에서 다이렉트X를 쉽게 사용할 수 있도록 해주는 모듈을

제공해주는 웹사이트도 있는데 관심 있는 독자라면 이 사이트

(http://www.delphi-jedi.org/DelphiGraphi cs/)를 방문해보기 바란다.

참고문헌

1) http://www.microsoft.com/directx

2) 윈도 95용 Game SDK 전략 가이드, 정보 문화사, 차주현, 박상욱 역

3) http://www.aros.net/~npawn/tutorial.htm

4) http://www.ziron.com/links/directx/

5) http://www.aha.ru/~pervago/

6) DirectX Foundation 도움말

- 끝 -

- the end of this article -

less..

less..

 

이번 예제는 Direct3D Retained Mode (D3D RM)의 첫 번째 예제로써 가장 기본적인 설정에 대해 알아볼 것이다. MFC의 뷰-도큐먼트 구조를 이용할 것인데, 여기서의 코드는 모두 뷰 클래스에서만 기술될 것이다. 코드를 작성하기 전에 DirectX SDK를 먼저 받아서 설치해야 할 것이다. 여기서는 7.0 버전의 SDK를 사용했지만 실제로 다음의 코드는 아마 direct x 3.0 버전에서도 컴파일될 것이다. 상위 버전의 기능을 이용하는 예제는 나중에 다시 살펴볼 것이다.

예제의 결과를 간단히 설명하자면 DirectX.bmp 라는 파일을 읽어들여서 육면체에 텍스처를 입히는 예제이다.

소스는 여기서 받으면 되지요. (비트맵 파일은 리소스에서 복사해서 넣으면 됩니다.)

1. SDI, 프로젝트 이름은 D3DCubic으로 정한다.

2. 메뉴에서 Project - Settings.. - Link에서 Object/library modules 에 다음을 써넣는다.

d3drm.lib     ddraw.lib

3. 텍스처, 육면체, 노멀벡터에 관한 데이터를 뷰의 cpp파일의 앞부분에 추가한다.

int faces[] = { 4, 0, 1,  1, 1,  2, 1,  3, 1,     // 위쪽
                      4, 4, 3,  5, 3,  6, 3,  7, 3,     // 아래쪽
                      4, 8, 2,  9, 2,  10, 2,  11, 2,   // 오른쪽
                      4, 12, 0,  13, 0,  14, 0,  15, 0, // 왼쪽
                      4, 16, 4,  17, 4, 18, 4, 19, 4,   // 앞쪽
                      4, 20, 5,  21, 5,  22, 5, 23, 5,  // 뒤쪽
                      0 };    
D3DVECTOR cubicVertices[] = {   1.0f, 1.0f, -1.0f,        // 0
                                                 -1.0f, 1.0f,  -1.0f,      // 1
                                                 -1.0f, 1.0f, 1.0f,         // 2
                                                   1.0f, 1.0f, 1.0f,         // 3
                                                   1.0f, -1.0f, -1.0f,      // 4
                                                   1.0f, -1.0f, 1.0f,       // 5
                                                 -1.0f, -1.0f, 1.0f,       // 6
                                                 -1.0f, -1.0f,  -1.0f,    // 7
                                                   1.0f, 1.0f, -1.0f,      // 8
                                                   1.0f, 1.0f, 1.0f,         // 9
                                                   1.0f, -1.0f, 1.0f,        // 10
                                                   1.0f, -1.0f, -1.0f,       // 11
                                                  -1.0f, 1.0f,  -1.0f,       // 12
                                                  -1.0f, -1.0f,  -1.0f,     // 13
                                                  -1.0f, -1.0f, 1.0f,       // 14
                                                  -1.0f, 1.0f, 1.0f,         // 15
                                                    1.0f, 1.0f, -1.0f,        // 16
                                                    1.0f, -1.0f, -1.0f,      // 17
                                                  -1.0f, -1.0f,  -1.0f,     // 18
                                                  -1.0f, 1.0f,  -1.0f,      // 19
                                                    1.0f, 1.0f, 1.0f,         // 20
                                                  -1.0f, 1.0f, 1.0f,        // 21
                                                  -1.0f, -1.0f, 1.0f,       // 22
                                                    1.0f, -1.0f, 1.0f,        // 23
                                           };
D3DVECTOR cubicNormals [] = { -1.0f, 0.0f,  0.0f,       // 0 - 왼쪽
                                                   0.0f, 1.0f,  0.0f,      // 1 - 위쪽
                                                   1.0f, 0.0f,  0.0f,       // 2 - 오른쪽
                                                   0.0f, -1.0f, 0.0f,       // 3 - 아래쪽
                                                   0.0f, 0.0f,  -1.0f,      // 4 - 앞쪽(-z방향)
                                                   0.0f, 0.0f,  1.0f        // 5 - 뒤쪽(+z방향)
                                               };

4. 뷰의 헤더파일에 다음 멤버변수를 추가한다.

// Attributes
public:
        LPDIRECT3DRM pD3DRM;                           // Direct3D retained mode Object
        LPDIRECT3DRMFRAME pD3DSceneFrame;   // Direct3D Scene Frame
        LPDIRECT3DRMFRAME pD3DCameraFrame; // Direct3D Camera Frame
        LPDIRECTDRAWCLIPPER pDDClipper;          // DirectDraw Clipper
        LPDIRECT3DRMDEVICE pD3DRMDevice;      // Direct3D Device
        LPDIRECT3DRMVIEWPORT pD3DViewport;   // Direct3D Viewport

5. 뷰의 생성자에서 멤버변수들에 대한 초기화를 한다.

CD3DCubicView::CD3DCubicView()
{
        // TODO: add construction code here
        pD3DRM = NULL;
        pD3DSceneFrame = NULL;
        pD3DCameraFrame = NULL;
        pDDClipper = NULL;
        pD3DRMDevice = NULL;
        pD3DViewport = NULL;
}

6. D3D RM의 설정을 하는 다음 함수를 추가한다. 코드를 보면 알 수 있겠지만 이 함수에서 D3D RM의 인터페이스를 생성하고, Scene 프레임, Camera 프레임, 클리퍼, 디바이스, 뷰포트, 렌더링 등의 설정을 한다.

BOOL CD3DCubicView::SetupD3DRM()
{
        // Direct3D RM 인터페이스 생성
        if(Direct3DRMCreate(&pD3DRM) != D3DRM_OK) {
                ::AfxMessageBox("Direct3D Retained Mode Interface Creation failure!");
                return FALSE;
        }
        // Scene Frame 생성
        if(pD3DRM->CreateFrame(NULL, &pD3DSceneFrame) != D3DRM_OK) {
                ::AfxMessageBox("Scene Frame Creation Failure!");
                return FALSE;
        }
        // Camera Frame 생성
        if(pD3DRM->CreateFrame(pD3DSceneFrame, &pD3DCameraFrame) != D3DRM_OK) {
                ::AfxMessageBox("Camera Frame Creation Failure!");
                return FALSE;
        }
        // 클리퍼를 생성하고 윈도우와 결합한다.
        if(DirectDrawCreateClipper(0, &pDDClipper, NULL) != DD_OK) {
                ::AfxMessageBox("Could not create clipper!");
                return FALSE;
        }
        if(pDDClipper->SetHWnd(0, m_hWnd) != DD_OK) {
                ::AfxMessageBox("Could not associate clipper with window!");
                return FALSE;
        }
        // Device 생성
        if(!CreateDevice()) {
                ::AfxMessageBox("Device Creation Failure!");
                return FALSE;
        }
        // Viewport 생성
        if(!CreateViewport()) {
                ::AfxMessageBox("Viewport Creation Failure!");
                return FALSE;
        }
        // 광원 생성
        if(!SetRenderingLights()) {
                ::AfxMessageBox("Lights Creation Failure!");
                return FALSE;
        }
        // Scene Rendering
        if(!RenderingScene()) {
                ::AfxMessageBox("Scene Creation Failure!");
                return FALSE;
        }
        return TRUE;
}

7. OnInitialUpdate() 함수에서 다음과 같이 SetupD3DRM() 함수를 호출한다.

void CD3DCubicView::OnInitialUpdate()
{
        CView::OnInitialUpdate();
        // TODO: Add your specialized code here and/or call the base class
if(!SetupD3DRM())
                PostQuitMessage(0);
}

8. 디바이스를 설정하는 CreateDevice() 함수는 다음과 같다.

BOOL CD3DCubicView::CreateDevice()
{
        RECT rect;
        // 현재의 윈도우 영역을 정한다.
        GetClientRect(&rect);
        if(!rect.right || !rect.bottom)
                return FALSE;
        // 디바이스 생성
        if(pD3DRM->CreateDeviceFromClipper(pDDClipper, NULL,
                rect.right, rect.bottom, &pD3DRMDevice) != D3DRM_OK) {
                return FALSE;
        }
        return TRUE;
}

9. 뷰포트를 설정하는 CreateViewport() 함수는 다음과 같다.

BOOL CD3DCubicView::CreateViewport()
{
        // Viewport 생성
        if(pD3DRM->CreateViewport(pD3DRMDevice, pD3DCameraFrame,
                0, 0, pD3DRMDevice->GetWidth(), pD3DRMDevice->GetHeight(),
                &pD3DViewport) != D3DRM_OK)
                return FALSE;
        return TRUE;
}

10. 광원을 설정하고, 배경색도 정하고, Quality 도 정하는 함수 - SetRenderingLights()

BOOL CD3DCubicView::SetRenderingLights()
{
        LPDIRECT3DRMLIGHT pAmbient = NULL;
        LPDIRECT3DRMLIGHT pPoint = NULL;
        // point 광원 생성
        if(FAILED(pD3DRM->CreateLightRGB(D3DRMLIGHT_POINT,
                0.4f, 0.4f, 0.4f, &pPoint)))
                return FALSE;
        if(FAILED(pD3DSceneFrame->AddLight(pPoint)))
                return FALSE;
        // ambient 광원 생성
        if(FAILED(pD3DRM->CreateLightRGB(D3DRMLIGHT_AMBIENT,
                0.8f, 0.8f, 0.8f, &pAmbient)))
                return FALSE;
        if(FAILED(pD3DSceneFrame->AddLight(pAmbient)))
               return FALSE;
        // Scene 배경색을 회색으로 설정
        pD3DSceneFrame->SetSceneBackground(D3DRGB(0.5, 0.5, 0.5));
        // Quality 설정
        pD3DRMDevice->SetQuality(D3DRMRENDER_GOURAUD);
        return TRUE;
}

11. 비트맵을 불러와서 렌더링을 하는 함수.

BOOL CD3DCubicView::RenderingScene()
{
        // Mesh builder interface
        LPDIRECT3DRMMESHBUILDER pMeshBuilder = NULL;
        LPDIRECT3DRMFRAME pCubicFrame = NULL;  // Cubic을 포함할 프레임
        LPDIRECT3DRMTEXTURE pTexture = NULL;
        // Mesh builder 생성
        if(FAILED(pD3DRM->CreateMeshBuilder(&pMeshBuilder)))
                return FALSE;
        // Texture Load
        if(FAILED(pD3DRM->LoadTexture("directx.bmp", &pTexture)))
                return FALSE;
        // 정점 배열로부터 페이스를 로드한다.
        pMeshBuilder->AddFaces(24, cubicVertices, 24,
                cubicNormals, (unsigned long *)faces, NULL);
        pMeshBuilder->SetColor(D3DRGB(1, 1, 1));
        pMeshBuilder->SetTexture(pTexture);
        // Texture Mapping
        for(int i=0; i<24; i+=4) {
                pMeshBuilder->SetTextureCoordinates(i, 0.0f, 0.0f);
                pMeshBuilder->SetTextureCoordinates(i+1, 1.0f, 0.0f);
                pMeshBuilder->SetTextureCoordinates(i+2, 1.0f, 1.0f);
                pMeshBuilder->SetTextureCoordinates(i+3, 0.0f, 1.0f);
        }
        // Frame 생성
        if(FAILED(pD3DRM->CreateFrame(pD3DSceneFrame, &pCubicFrame)))
                return FALSE;
        // Frame에 Mesh Builder 추가
        if(FAILED(pCubicFrame->AddVisual(pMeshBuilder)))
                return FALSE;
        // Camera Frame 위치 설정
        if(FAILED(pD3DCameraFrame->SetPosition(pD3DSceneFrame, 0.0f,
                0.0f, -7.0f)))
                return FALSE;
        // interface Release
        pCubicFrame->Release();
        pMeshBuilder->Release();
        pTexture->Release();
        return TRUE;
}

12. OnDraw() 함수 대신에 OnPaint() 함수를 호출한다.

void CD3DCubicView::OnPaint()
{
        CPaintDC dc(this); // device context for painting
        // TODO: Add your message handler code here
        if(!pD3DRMDevice || IsIconic())
                return;
        pD3DViewport->Clear();                               // Viewport Clear
        pD3DViewport->Render(pD3DSceneFrame);  // Scene Rendering
        pD3DRMDevice->Update();                         // Device Update
        // Do not call CView::OnPaint() for painting messages
}

13. 윈도우의 크기가 바뀜에 따라 디바이스와 뷰포트를 다시 설정한다.

void CD3DCubicView::OnSize(UINT nType, int cx, int cy)
{
        CView::OnSize(nType, cx, cy);
        // TODO: Add your message handler code here
        if(!pD3DViewport) return;
        if(!pD3DRMDevice) return;
        int width = cx;
        int height = cy;
        if(!width || !height || IsIconic()) return;
        // Device와 Viewport의 현재 폭과 높이를 얻는다.
        int vWidth = pD3DViewport->GetWidth();
        int vHeight = pD3DViewport->GetHeight();
        int dWidth = pD3DRMDevice->GetWidth();
        int dHeight = pD3DRMDevice->GetHeight();
        // window 크기에 변함이 없으면 리턴한다.
        if(vWidth == width && vHeight == height) return;
        // 아니면 Device와 Viewport를 다시 생성한다.
        pD3DViewport->Release();
        pD3DRMDevice->Release();
        if(!CreateDevice()) {
                ::AfxMessageBox("Device Creation Failure!");
                PostQuitMessage(0);
        }
        if(!CreateViewport()) {
                ::AfxMessageBox("Viewport Creation Failure!");
                PostQuitMessage(0);
        }
}

14. 키보드의 화살표 키에 따라 육면체가 움직이도록 한다.

void CD3DCubicView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
        // TODO: Add your message handler code here and/or call default
        LPDIRECT3DRMFRAMEARRAY pFrameArray;    // Frame Array
        LPDIRECT3DRMFRAME pChildFrame;        // 얻고자하는 Frame
        // Frame Array를 얻는다.
        pD3DSceneFrame->GetChildren(&pFrameArray);
        // 우리가 원하는 Frame을 얻는다.
        pFrameArray->GetElement(1, &pChildFrame);
        // Frame을 rotate한다.
        if(nChar == VK_UP)
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   1.0f, 0.0f, 0.0f, 0.1f);
        if(nChar == VK_DOWN)
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   1.0f, 0.0f, 0.0f, -0.1f);
        if(nChar == VK_LEFT)
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   0.0f, 1.0f, 0.0f, 0.1f);
        if(nChar == VK_RIGHT)
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   0.0f, 1.0f, 0.0f, -0.1f);
        pFrameArray->Release();
        pChildFrame->Release();
        InvalidateRect(NULL, FALSE);  // 윈도우를 다시 그린다.
        CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

- the end of this article -

less..

less..

 

이번 예제도 역시 Direct3D Retained Mode(D3D RM)를 이용하는 것인데, 앞의 Sample 1 과는 달리 DirectX 6.0 이상 버전의 기능을 사용할 것이다. 그러므로 당연히 6.0 이상의 DirectX 런타임이 설치되어 있어야 할 것이다. 실제로 D3D RM에서 사용되는 API들은 6.0 버전에서 개발이 중단되었고, Immidiate Mode(IM)에서 사용되는 API 개발에 노력이 집중되었다. 그러므로 RM을 사용한다면 6.0 버전 이상을 쓴다고 해도 더 나은 점은 없다.

만들 프로그램에 대해 간략히 소개를 하자면, 이번 예제는 Direct3D에서 지원하는 파일 포맷인 X 파일을 읽어들이는 프로그램이고, X파일은 인터넷 상에서 구한 3DS 파일을 SDK의 conv3ds.exe를 이용해 X파일로 바꾼 것이다.

참고로 3DS 와 같은 3D 모델링 파일이 많이 있는 사이트를 소개하자면 http://www.3dcafe.com 이 무난하겠다. 물론 검색엔진으로 직접 찾아보면 다른 좋은 사이트들도 많을 것이다.

이 예제에서 사용한, conv3ds.exe 파일의 사용법과 옵션에 대해 간단히 설명하면 다음과 같다.

sample.3ds 파일을 sample.x 파일로 바꾸려고 할 때

conv3ds -m sample.3ds

물론 -m 옵션 외에도 여러 가지 옵션이 있지만 여기서 사용한 것은 계층구조가 없는 single mesh 형식이므로 -m 옵션을 사용하였다. 확장자가 .X 이더라도 계층구조나 키프레임의 유무 등등 여러 가지 형식이 있고, 이에 따라 X파일을 불러들일 때 사용되는 함수가 달라진다. -m 옵션을 사용했을 때는 meshbuilder 의 Load 함수를 사용하면 된다.

지금까지 글이 이해가 안되더라도 전혀 상관할 필요없다. 홈주인은 그런거 신경쓰지도 않고, 다음 예제를 그대로 따라해 보면 결과는 똑같이 나올테니까 말이다..

이제 실제 코딩을 해 보자... 예제 프로젝트는 여기에서 다운로드.

1. 우선 X형식의 파일을 하나 장만해서 프로젝트 폴더에 복사해 넣는다. 이 예제에서 사용할 X 파일의 이름은 55porsmx.x 이다. 3차원 모델링 파일은 다른걸 구해서 X형식으로 변환해서 쓰거나 직접 만들어서 변환해 써도 무난하겠다.

2. AppWizard에서 SDI 로 프로젝트를 하나 만든다. 여기서 프로젝트 이름은 XLoader라고 정했다. 옵션은 모두 디폴트로 사용해도 관계없다.

3. DirectX 파일을 링크시키기 위해 메뉴의 Project - Settings.. - Link에서 Object/library modules 에 다음을 써넣는다.

ddraw.lib d3drm.lib d3dxof.lib dxguid.lib

4. 뷰의 헤더파일 앞부분에 다음을 추가한다.

#define INITGUID
#include "d3drmwin.h"

5. 뷰의 헤더파일에 다음 멤버변수를 추가한다.

LPDIRECT3DRM3         pD3DRM;           // Direct3D retained mode Object
LPDIRECTDRAWCLIPPER   pDDClipper;       // DirectDraw Clipper Object
LPDIRECT3DRMDEVICE3   pD3DRMDevice;     // Direct3D Device
LPDIRECT3DRMVIEWPORT2 pD3DViewport;     // Direct3D Viewport
LPDIRECT3DRMFRAME3    pD3DSceneFrame;   // Direct3D Scene Frame
LPDIRECT3DRMFRAME3    pD3DCameraFrame;  // Direct3D Camera Frame

6. 뷰의 생성자에서 멤버변수들에 대한 초기화를 한다.

CXLoaderView::CXLoaderView()
{
        // TODO: add construction code here
pD3DRM = NULL;          
       pDDClipper = NULL;              
       pD3DRMDevice = NULL;    
       pD3DViewport = NULL;    
       pD3DSceneFrame = NULL;  
       pD3DCameraFrame = NULL;
}

7. 뷰의 cpp 파일의 앞부분에 다음과 같은 매크로 함수를 한줄 넣는다.

#define SAFE_RELEASE(x) if (x != NULL) {x->Release(); x = NULL;}

8. 뷰의 소멸자에서, 헤더파일에 정의한 변수들의 메모리를 다음과 같이 해제한다.

CXLoaderView::~CXLoaderView()
{
SAFE_RELEASE(pD3DRM);          
       SAFE_RELEASE(pDDClipper);       
       SAFE_RELEASE(pD3DRMDevice);    
       SAFE_RELEASE(pD3DViewport);    
       SAFE_RELEASE(pD3DSceneFrame);  
       SAFE_RELEASE(pD3DCameraFrame);
}

9. OnInitialUpdate() 함수를 다음처럼 오버라이드한다.

void CXLoaderView::OnInitialUpdate()
{
        CView::OnInitialUpdate();
        // TODO: Add your specialized code here and/or call the base class
       if(!SetupD3DRM())
               PostQuitMessage(0); }

10. D3D RM의 설정을 하는 다음 함수를 추가한다. 코드를 보면 알 수 있겠지만 이 함수에서 D3D RM의 인터페이스를 생성하고, Scene 프레임, Camera 프레임, 클리퍼, 디바이스, 뷰포트, 렌더링 등의 설정을 한다.

// D3DRM 초기화하는 함수
BOOL CXLoaderView::SetupD3DRM()
{
        LPDIRECT3DRM pD3DRM1;
        // D3DRM의 객체 생성
        if(FAILED(Direct3DRMCreate(&pD3DRM1))) {
                ::AfxMessageBox("Failed to create Direct3DRM.");
                return FALSE;
        }
        // 새버전의 D3DRM의 객체 생성
        if(FAILED(pD3DRM1->QueryInterface(IID_IDirect3DRM3, (void **)&pD3DRM))) {
                ::AfxMessageBox("Failed to QI for Direct3DRM3.");
                return FALSE;
        }
        // clipper를 생성하고 윈도우와 결합
        if(FAILED(DirectDrawCreateClipper(0, &pDDClipper, NULL))) {
                ::AfxMessageBox("Failed to create DirectDrawClipper.");
                return FALSE;
        }
        if(FAILED(pDDClipper->SetHWnd(0, m_hWnd))) {
                ::AfxMessageBox("Failed to set hwnd on the clipper.");
                return FALSE;
        }
        // scene frame 생성
        if(FAILED(pD3DRM->CreateFrame(NULL, &pD3DSceneFrame))) {
                ::AfxMessageBox("Failed to create the master scene frame.");
                return FALSE;
        }
        // camera frame 생성
        if(FAILED(pD3DRM->CreateFrame(pD3DSceneFrame, &pD3DCameraFrame))) {
                ::AfxMessageBox("Failed to create the camera's frame.");
                return FALSE;
    }
        // camera 위치 지정
        if(FAILED(pD3DCameraFrame->SetPosition(pD3DSceneFrame, 0.0f, 0.0f, 0.0f))) {
                ::AfxMessageBox("Failed to position the camera in the frame.");
                return FALSE;
        }
        // Device 생성
        if(!CreateDevice()) {
                ::AfxMessageBox("Device Creation Failure.");
                return FALSE;
        }
        // Viewport 생성
        if(!CreateViewport()) {
                ::AfxMessageBox("Viewport Creation Failure.");
                return FALSE;
        }
        // 광원 생성
        if(!SetRenderingLights()) {
                ::AfxMessageBox("Lights Creation Failure.");
                return FALSE;
        }
        // 렌더링 상태 설정
        if(!SetRenderingState()) {
                ::AfxMessageBox("Lendering State Failure.");
                return FALSE;
        }
        // Scene 렌더링
        if(!RenderingScene()) {
                ::AfxMessageBox("Scene Rendering Failure.");
                return FALSE;
        }
        return TRUE;
}

11. 디바이스를 생성하는 CreateDevice 함수를 작성한다.

// Device를 생성하는 함수
BOOL CXLoaderView::CreateDevice()
{
        RECT rect;
         // 현재의 윈도우 영역을 정한다.
        GetClientRect(&rect);
        if(!rect.right || !rect.bottom)
                return FALSE;
        // 디바이스 생성
        if(FAILED(pD3DRM->CreateDeviceFromClipper(pDDClipper, NULL,
                               rect.right, rect.bottom, &pD3DRMDevice)))
                return FALSE;
        return TRUE;    
}

12. 뷰포트와 Z버퍼의 깊이를 정하는 함수 CreateViewport()를 작성한다.

// viewport를 생성하는 함수
BOOL CXLoaderView::CreateViewport()
{
        // Viewport 생성
        if(FAILED(pD3DRM->CreateViewport(pD3DRMDevice, pD3DCameraFrame,
                      0, 0, pD3DRMDevice->GetWidth(), pD3DRMDevice->GetHeight(),
                  &pD3DViewport)))
                return FALSE;
        // z버퍼의 깊이지정
        pD3DViewport->SetBack(5000.0f);
        return TRUE;
}

13. 광원을 설정하는 함수 SetRenderingLights() 함수를 작성한다.

// 광원(Lights)을 설정하는 함수
// CreateLightRGB의 첫번째 인자로 사용가능한 값들 :
//      D3DRMLIGHT_AMBIENT, D3DRMLIGHT_POINT, D3DRMLIGHT_SPOT,
//      D3DRMLIGHT_DIRECTIONAL, D3DRMLIGHT_PARALLELPOINT
BOOL CXLoaderView::SetRenderingLights()
{
        LPDIRECT3DRMLIGHT pAmbient = NULL;
        LPDIRECT3DRMLIGHT pPoint = NULL;
        // point 광원 생성
        if(FAILED(pD3DRM->CreateLightRGB(D3DRMLIGHT_POINT,
                0.4f, 0.4f, 0.4f, &pPoint)))
                return FALSE;
        if(FAILED(pD3DSceneFrame->AddLight(pPoint)))
                return FALSE;
        // ambient 광원 생성
        if(FAILED(pD3DRM->CreateLightRGB(D3DRMLIGHT_AMBIENT,
                0.8f, 0.8f, 0.8f, &pAmbient)))
                return FALSE;
        if(FAILED(pD3DSceneFrame->AddLight(pAmbient)))
                return FALSE;   
        return TRUE;

}

14. 배경색이나 디더링, Quality 등을 결정하는 SetRenderingState() 함수를 작성한다.

// 렌더링 상태를 설정하는 함수
// SetQuality의 인자로 가능한 값들 :
//        D3DRMRENDER_WIREFRAME, D3DRMRENDER_UNLITFLAT, D3DRMRENDER_FLAT     
//        D3DRMRENDER_GOURAUD,   D3DRMRENDER_PHONG   
// 필요할 경우 여기서 texture나 shade에 대한 설정을 할 것
BOOL CXLoaderView::SetRenderingState()
{
        // Scene 배경색을 검은색으로 설정
        if(FAILED(pD3DSceneFrame->SetSceneBackground(D3DRGB(0.5, 0.5, 0.5))))
                return FALSE;
        // 렌더링 Quality 설정
        if(FAILED(pD3DRMDevice->SetQuality(D3DRMRENDER_FLAT)))
                return FALSE;
        // Dithering 여부 설정
        if(FAILED(pD3DRMDevice->SetDither(FALSE)))
                return FALSE;
        return TRUE;
}

15. 외부파일을 불러들여 렌더링하는 함수 RenderingScene() 함수를 작성한다.

// Scene을 렌더링하는 부분  
BOOL CXLoaderView::RenderingScene()
{
        LPDIRECT3DRMMESHBUILDER3 pMeshBuilder = NULL;
        LPDIRECT3DRMFRAME3       pMeshFrame = NULL;  // 불러들일 mesh를 포함할 프레임
        // Mesh builder 생성
        if(FAILED(pD3DRM->CreateMeshBuilder(&pMeshBuilder)))
                return FALSE;
        // Load mesh file : camaro.x 파일을 불러들임
        if(FAILED(pMeshBuilder->Load("55porsmx.x", NULL, D3DRMLOAD_FROMFILE,
                                          NULL, NULL))) {
                SAFE_RELEASE(pMeshBuilder);
                SAFE_RELEASE(pMeshFrame);
                return FALSE;
        }
        // SceneFrame 안에 Mesh를 위한 Frame 생성
        if(FAILED(pD3DRM->CreateFrame(pD3DSceneFrame, &pMeshFrame)))
                return FALSE;
        // Frame에 불러들인 mesh 붙이기
        if(FAILED(pMeshFrame->AddVisual((LPDIRECT3DRMVISUAL)pMeshBuilder)))
                return FALSE;
        // Set up the frames position, orientation and rotation
        if(FAILED(pD3DCameraFrame->SetPosition(pD3DSceneFrame, 1.0f, -0.9f, -12.5f)))
                return FALSE;
        if(FAILED(pD3DCameraFrame->SetOrientation(pD3DSceneFrame,
                0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f)))
                return FALSE;
        if(FAILED(pMeshFrame->SetRotation(pD3DSceneFrame, 0.0f, 1.0f, 0.0f, 0.02f)))
                return FALSE;
        // 초기에 필요한 만큼 mesh객체를 돌리기 위해 AddRotation 사용
        if(FAILED(pMeshFrame->AddRotation(D3DRMCOMBINE_AFTER, 0.0f, 1.0f, 0.0f, 2.4f)))
                return FALSE;
        if(FAILED(pMeshFrame->AddRotation(D3DRMCOMBINE_AFTER, 1.0f, 0.0f, 0.0f, -0.3f)))
                return FALSE;
        SAFE_RELEASE(pMeshFrame);
        SAFE_RELEASE(pMeshBuilder);
        return TRUE;
}

16. OnDraw가 아니고 OnPaint를 사용한다. 다음처럼 OnPaint 함수작성.

// OnDraw()를 사용하지 않고 OnPaint() 사용
void CXLoaderView::OnPaint()
{
        CPaintDC dc(this); // device context for painting
        // TODO: Add your message handler code here
       if(!pD3DRMDevice || IsIconic())
               return;
       pD3DViewport->Clear(D3DRMCLEAR_ALL);   // Viewport Clear
       pD3DViewport->Render(pD3DSceneFrame);  // Scene Rendering
       pD3DRMDevice->Update();                // Device Update         // Do not call CView::OnPaint() for painting messages
}

17. 뷰의 크기가 바뀔 경우의 처리를 위해 OnSize() 함수를 오버라이드 한다.

// 뷰의 크기가 바뀔경우의 처리를 위해
void CXLoaderView::OnSize(UINT nType, int cx, int cy)
{
        CView::OnSize(nType, cx, cy);
        // TODO: Add your message handler code here
        if(!pD3DViewport) return;
        if(!pD3DRMDevice) return;
        int width = cx;
        int height = cy;
        if(!width || !height || IsIconic()) return;
        // Device와 Viewport의 현재 폭과 높이를 얻는다.
        int vWidth = pD3DViewport->GetWidth();
        int vHeight = pD3DViewport->GetHeight();
        int dWidth = pD3DRMDevice->GetWidth();
        int dHeight = pD3DRMDevice->GetHeight();
        // window 크기에 변함이 없으면 리턴한다.
        if(vWidth == width && vHeight == height) return;
       // 아니면 Device와 Viewport를 다시 생성한다.
        pD3DViewport->Release();
        pD3DRMDevice->Release();
        if(!CreateDevice()) {
                ::AfxMessageBox("Device Creation Failure!");
                PostQuitMessage(0);
        }
        if(!CreateViewport()) {
                ::AfxMessageBox("Viewport Creation Failure!");
                PostQuitMessage(0);
        }               
}

18. 방향키로 자동차 모델을 움직이게 하기 위해 클래스 위저드에서 WM_KEYDOWN 메시지의 핸들러를 작성한다.

// 방향키로 자동차 모델을 움직일 수 있도록 함
// rotation : 방향키, translation : Insert, Home, PgUp, PgDn
void CXLoaderView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
        // TODO: Add your message handler code here and/or call default
        LPDIRECT3DRMFRAMEARRAY pFrameArray;    // Frame Array
        LPDIRECT3DRMFRAME pChildFrame;         // 얻고자하는 Frame
        // Frame Array를 얻는다.
        pD3DSceneFrame->GetChildren(&pFrameArray);
        // 우리가 원하는 Frame을 얻는다.
        pFrameArray->GetElement(1, &pChildFrame);
        // Frame을 rotate한다.
        if(nChar == VK_UP)    // 위쪽 방향키
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   1.0f, 0.0f, 0.0f, 0.1f);
        if(nChar == VK_DOWN)  // 아래쪽 방향키
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   1.0f, 0.0f, 0.0f, -0.1f);
        if(nChar == VK_LEFT)  // 왼쪽 방향키
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   0.0f, 1.0f, 0.0f, 0.1f);
        if(nChar == VK_RIGHT)  // 오른쪽 방향키
                pChildFrame->AddRotation(D3DRMCOMBINE_AFTER,
                   0.0f, 1.0f, 0.0f, -0.1f);
        // Frame을 Translate한다.
        if(nChar == VK_PRIOR)  // Page Up 키 : 위쪽 (+y축 방향)
                pChildFrame->AddTranslation(D3DRMCOMBINE_AFTER,
                        0.0f, 0.1f, 0.0f);
        if(nChar == VK_NEXT)   // Page Down 키 : 아래쪽 (-y축 방향)
                pChildFrame->AddTranslation(D3DRMCOMBINE_AFTER,
                        0.0f, -0.1f, 0.0f);
        if(nChar == VK_INSERT) // Insert 키 : 왼쪽 (-x축 방향)
                pChildFrame->AddTranslation(D3DRMCOMBINE_AFTER,
                        -0.1f, 0.0f, 0.0f);
        if(nChar == VK_HOME)   // Home 키 : 오른쪽 (+x축 방향)
                pChildFrame->AddTranslation(D3DRMCOMBINE_AFTER,
                        0.1f, 0.0f, 0.0f);
        pFrameArray->Release();
        pChildFrame->Release();
        InvalidateRect(NULL, FALSE);  // 윈도우를 다시 그린다.  
        CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

# 문제점

: 이 코드에서 불러들이는 모델을 작게 해서(RenderingScene() 함수에서 고칠 수 있다) 불러보면 배경처리에 문제가 있는 것을 알 수 있습니다.. 모델이 움직이는 부분에만 배경이 그려지고, 나머지는 배경이 그려지지 않는 문제가 있죠. 여기서는 모델의 크기를 적당히 맞추어서 그런 티가 안나게 조정했지만, 실제로 그렇게 만들어서 한번 돌려보면 알 수 있을 겁니다. 이 문제에 대한 해결책을 알고 계신분은 홈주인에게 연락을 해 주기 바랍니당.

- the end of this article -

less..