[강좌] <LeeChen> 윈도우 게임제작 I 08/30 20:26 153 line
안녕하세요~ 이준곤(LeeChen) 입니다.
요즘에 게임을 제작하는데 있어 도스용과 윈도우즈용이라는 분야로
나누어져 있더군요.
요즘 국산 게임은 워낙 뛰어난 것들이 많아서 게임 시장에 나가서
어떤 게임을 사야 할지 모르겠더군요~
게임은 만드는 재미도 있지만 실제로 제작되어 있는 게임을 즐길줄
아는 게임 메이커들이 되었으면 합니다.
사실 94년도에 썼던 스크립터에 관한 글을 계속 이어나가야 하는데
제가 시간이 없다보니(핑계인가?) 대신 다이렉트에 관한 글로 대신
하려고 합니다.
얼마전에 DirectX 5.0이 나왔죠? 3D기능이 엄청나게 좋아 졌더군요
기능향상이 이젠 3차원 게임을 게임 메이커라면 누구나 할수 있는
수준이니까요~
일단 다이렉트 엑스라는 개발툴을 사용하려면 비쥬얼 2.0이상이
있어야 합니다. (당연 32비트 개발툴을 뜻하는 것이겠죠~)
또는 볼랜드의 빌더라는 것을 쓰시면 됩니다.
일단 다이렉트(이하 편의상 다이렉트라고만 표시하겠음)를 설치하
고 나면 샘플이라는 디렉토리로 가서 갔가지 데모를 보십시요?
아니 이럴수가? 또는 이게뭐야? 이것 밖에 안되? 하는 등등의 여
러가지 표현을 하실텐데...
우선 Foxbear라는 프로그램에는 2D에서 표현되는 모든 기법들이
들어 있다고 할수 있더군요~ (많은 예제를 참고 하심이 좋을 듯...)
먼저 참고 서적을 보시려면...
1. 자체 온라인 메뉴얼 (당연 영문이죠~ 번역 가능한자만...^^;)
2. Windows 95 Game 개발자 가이드 - 도서출판 에프원
3. 윈도우 95용 Game SDK 전략 가이드 - 정보문화사
4. 윈도우 API 바이블 I, II - 생각안남
5. 윈도우 함수 레퍼런스 상,중,하 (2만8천원 짜리 3권인가?
- 역시 기억안남)
6. Inside Visual C++
7. MFC 관련 책자
8. 기타 윈도우즈 관련 책자및 참고 할만한 책들
우와~ 많죠? 전 위에서 모든 책을 읽어 보진 못했지만...^^;
참고는 항시 하고 있습니다. 책을 파는 사람이 아니므로 도서관이나
서점에서 잠시 보시거나 참고 하기 위해 복사나 참조 하세요~
굳이 사실 분은 사시구요~ (프로그래머라면 책에 쓰는 돈은 아까워
하면 안되겠죠~)
본론으로 들어가죠~ 괜히 책에 관한 이야기만 많이 늘어 놓은듯..--;
1. 비트맵을 출력하는 모식도
┌──────────────────┐
│ 윈도우 생성, 초기화 한다. │
└─────────┬────────┘
┌─────────┴────────┐
│ DirectDraw의 인터페이스 │
└─────────┬────────┘
┌─────────┴────────┐
│ Off Screen으로 비트맵 복사 │
└────┬─────────┬───┘
┌────┴───┐ ┌───┴───┐
│ 스프라이트 Blt │ │ 배경 Blt │ <- 후면 버퍼로
└────┬───┘ └───┬───┘ 보내는 과정
┌────┴─────────┴───┐
│ 실제 보이는 화면으로 Fliping │
└──────────────────┘
그림 1 : 다이렉트 액스 출력 과정 모식도
위에서 보면 인터페이스 하는 부분외에는 도스에서 게임을
제작하는 과정과 흡사하다고 볼수 있죠~
사실 인터페이스 부분은 자신의 라이브러리를 사용하는
부분이라고 생각해도 될겁니다.
2. DirectDraw의 데이터 스트럭쳐
다이렉트를 사용하기 위해선 큰지막한 구조체들을 알아야
한다. 이번에는 그 구조를 알기 위해 분석을 해보자.
자세하게는 하지 않고 대강 이렇다고 정의만 하겠다.
──────────────────────────
DDCAPS
──────────────────────────
비디오 카드의 상태를 확인및 체크한다.
예) 메모리의 양, 하드웨어의 능력(3D)
──────────────────────────
DDRVAL
──────────────────────────
DirectDraw 함수들이 반환하는 값을 뜻한다.
──────────────────────────
DDSCAPS
──────────────────────────
DDCAPS와 거의 비슷한데 DDCAPS는 하드웨어의 기능을
체크하는 것이라면 이것은 소프트웨어의 기능을 체크한다.
즉, DirectDrawSurface의 능력을 체크한다.
──────────────────────────
DDSURFACEDESC
──────────────────────────
생성한 각각의 표면(또는 버퍼)에 대한 Off Screen을
뜻한다.
잉? 이것이 전부인가? 일단 Draw에 관한 것을 다루도록하
기로 하고 이것이 여기서 마치고...
3. DirectDraw의 생성
그럼 실제로 DirectDraw를 어떻게 인터페이스 하고 초기화
하는지 알아 봅시다.
──────────────────────────
HRESULT DirectDrawCreate(GUID FAR *lpGUID,
LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter)
──────────────────────────
윈도우즈 관련 함수를 보면 Create관련 함수를 많이볼수
있습니다. 다이렉트도 비슷한 방식을 쓰는데 데부분 초기화
또는 생성등을 할때 쓰이는 함수들이 Create라는 부분이
명시되어 있습니다.
그럼 위의 함수의 인자들은 무엇을 뜻할까요?
lpGUID는 디스플레이 디바이스를 뜻합니다. 이것이 무슨 뜻
이냐구요? 화면에 나타나기 위한 장치를 뜻한다는 이야기죠
보통 이값이 NULL이면 GDI에 공유된 디스플레이를 뜻합니다
lpDD는 DirectDraw 인터페이스를 위한 포인터를 가리키고,
마지막 인자는 향후 사용되기 위해 예약해둔 것이라고 합니
다. 보통 NULL이라고 하면 됩니다.
LPDIRECTDRAW lpDD;
HRESULT ddrval;
ddrval = DirectDrawCreate(NULL, &lpDD, NULL);
if(ddrval != DD_OK)
{
return FALSE;
}
아주 간단하죠? OLE COM에서 반환되는 형은 HRESULT를 사용
합니다. 오류가 발생하면 신속한 처리를 위해서 HRESULT를
사용합니다.
위의 예제는 생성하고자 하는 DirectDraw 객체를 선언하는
간단한 예제 입니다.
///////////////////////////////////////////
일단 오늘은 여기까지 입니다. 곧 (조만간) 두번째 글을 올리
도록 하겠습니다. 많은 분들께 참고가 되었으면 하는 바램으로
적어보았습니다.
성남에서 외로움을 달래며....
이준곤(LeeChen) 드림.
#1384 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [2] 09/02 22:37 183 line
안녕하세요~ 이준곤(LeeChen) 입니다.
지난번에 어디까지 했더라....^^;
이곳에 가끔씩 들려 보지만 요즘 공모전때문에 그런지 무척이나
활기 있어 보입니다.
오늘은 윈도우즈로 게임을 제작해 보는 두번째 시간 즐겁게 제
작해 봅시다.
보통 도스용 게임을 제작할때는 하드웨어적인 것을 개발해야 하
거나 (속도 문제로...) 상업적인 라이브러리를 사서 제작하는
경우가 다수였을 겁니다.
그리고, 멀티 테스킹을 하기 위한 자구책을 내놓기도 하였죠~
당연 이것을 얍삽한 프로그램방식이라고들 일부에서는 표현하면
서 사용을 했죠~
윈도우즈는 어떨까요? 사실 멀티테스킹, 네트워크상의 플레이,
사운드의 다양한 제어, 거기다 3차원 방법까지 쉽게 신경쓰지
않고 표현할수 있는 시대인것 같습니다.
잉? 자꾸 삼천포로 빠지는 군요~
1. 프로세서를 독점하기
일단 게임을 위해서는 프로세서를 독점할 필요성이 있겠다
고 생각하시죠? 당연 다이렉트로 이것을 사용자가 만들기
바라지 않고 자체 에서 지원합니다. 바로
SetCooperativeLevel()이라는 대표적인 함수가 있습니다.
─────────────────────────────
HRESULT SetCooperativeLevel(LPDIRECTDRAW lpDD, HWND hWnd,
DWORD dwFlags)
─────────────────────────────
lpDD는 앞에서 생성된 DirectDraw 객체에 대한 포인터를
뜻합니다. 두번째것은 당연 윈도우즈 핸들러겠죠?
보통 이헨들러는 작업전환(ALT+TAB)에 관한 메세지를 보낼
때 사용되어 집니다.
마지막 dwFlags에 관한건 다음의 내용을 보시면 설명보다
쉽게 이해가...
--------------------------------------------------------------
DDSCL_ALLOWMODEX ModeX를 지원한다. DirectDraw는 저해상도인
320x200, 3200x400의 X모드를 지원합니다.
DDSCL_ALLOWREBOOT 전체 화면을 사용할때 Ctrl+Alt+Del을 가능하
합니다.
DDSCL_EXCLUSIVE 해상도를 바꾸거나 플리핑 작업을 위해서
exclusive level 상태로 한다.
DDSCL_FULLSCREEN GDI를 사용하지 않는 전체화면 모드를 사용
가능하게 한다.
DDSCL_NORMAL 일반적인 윈도우즈 창에서 프로그램을 가능
하게 합니다.
DDSCL_NOWINDOWCHANGES 활성화 상태에 있는 프로그램을 minimize
할수 없게 합니다.
--------------------------------------------------------------
와우 무슨 옵션이 이렇게 많은가? 보통 프로그램에서는
위의 코드를 조합해서 사용합니다. 여기서 조합이란것은
OR, AND를 한다는 뜻입니다.
간단한 예를 보죠~
ddrval=lpDD->SetCooperativeLevel(hwnd,
DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
아주 간단해 보이시죠?
2. 비디오 모드 설정
앞서 배운 것은 단지 프로세서(CPU)자원의 독점하는 것을
배워 보았습니다.
이번에는 비디오 모드를 설정하는 방법을 알아 봅시다.
물론 관련책자를 보시면 자세히 알수 있지만, 그래도...
혹시나... 책이 없이 이글로 배움을 시작하는 분을 위해
다이렉트는 320x200, 320x400 640x480의 해상도를 지원합
니다. 256칼라를 기본으로 하지만 투루칼라까지 지원이
됩니다. 보통 640x480x256에서 가장 효율적인 기능을
제공한다고 메뉴얼에 나와 있더군요!
─────────────────────────────
HRESULT SetDisplayMode(LPDIRECTDRAW lpDD,
DWORD dwWidth, DWORD dwHeight,
DWORD dwBpp)
─────────────────────────────
역시 첫번째 인자는 DirectDraw를 뜻하는 것이겠죠~
dwWidth와 dwHeight는 가로 세로 해상도를 뜻하는 것이구요
마지막 dwBpp는 컬러수를 뜻합니다.
그럼 예제를 보죠~
ddrval=lpDD->SetDisplayMode(640, 480, 8);
위의 예제는 바로 640*480*256을 뜻합니다.
아주 쉽죠~ ^^;
자~ 여기까지 정리해 보죠~ 첫번째 두번째 글을 읽어 보셔도
아직 이해가 되지 않죠~ 당연히 아직은 그리 중요하지는
않은 내용인듯합니다. (당연한 내용이므로...^^;)
//우선 사용될 다이렉트 변수들을 선언해야 겠죠~
LPDIRECTDRAW lpDD;
LPDIRECTDRAWSURFACE lpDDSPrimary;
LPDIRECTDRAWSURFACE lpDDSBack;
DDSCAPS ddscaps;
DDSURFACEDESC ddsd;
HRESULT hr;
//그다음에 다이렉트 드로우에 관한 생성자를 생성했죠~
hr = DirectDrawCreate(NULL, &lpDD, NULL);
if(hr != DD_OK)
{
// 에러 관련 처리를 해야 겠죠?
// 보통 에러라고 표시를 하고 빠져 나갑니다.
}
// 자~ 그럼 이번에는 프로세서를 독점해야 겠죠~
hr = lpDD->SetCooperativeLevel(hWnd, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN | DDSCL_ALLOWMODEX);
if(hr != DD_OK)
{
// 동일한 에러 처리를 하면 되겠죠~
}
// 여기서 해상도를 설정해야 겠죠!
hr = lpDD->SetDisplayMode(640, 480, 8);
if( hr != DD_OK)
{
// 당연 에러 처리겠죠~
}
// 여기까지....
///////////////////////////////////////////////////////////////
일단 오늘은 여기까지 입니다. 쉽죠? 아닌가?......(끄적끄적)
세번째 글을 써야 겠는데.....잉? ...눈에....핏기가....
다음에는 버퍼의 생성관해서 장편의 글을 써보도록 해보겠습니다.
그리고 페이지 플리핑에 관해서다루어 보구요~
다음과 같이 연재해 나가도록 하겠습니다.
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
3. 다이렉트 버퍼 생성 전반에 관해
4. 면의 생성과 플리핑, 비트맵 복사
5. 다이렉트 팔레트 관리
6. Lock과 Unlock, Blt, BltFast
7. 다이렉트 사운드 처리
8. 조이스틱
9. 간단한 2D 게임을 제작
일단 여기까지가 1편.....
2편은 가능할지 모르지만....
10. 다이렉트 3D전반에 관해서...
11. 오버레이 표면과 Z버퍼, 이미지 회전, 알파 혼합기능
12. 다이렉트를 이용해 3D 텍스쳐 입히기
13. 다이렉트를 이용한 실시간 랜더링
14. 다이렉트 엑스에 OpenGL을 이용하자.
15. 3DS 분석과 오브젝 읽어 표현하기
15. 퀘이크를 흉내내자.
16. 버 И화이터를 만들자.
17. 기타 등등.
2편은 아직 제가 앞으로 시간이 어찌 될지? 싶어 장담은 할수
없어서 .... --; 그러나 1편은 확실히 연재해 나가 겠습니다.
현재 작업을 진행중이라서 글을 빨리 올리지 못하는 것에 대해
죄송하게 생각합니다.
3차원에 들어가면 내용이 1편에 배로 증가하겠군요...
음...타이핑 칠 시간이 있으려나? ^^;
많은 분들께 참고가 되었으면 하는 바램으로 적어보았습니다.
성남에서 외로움을 달래며....
이준곤(LeeChen) 드림.
#1385 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [3] 09/08 08:14 254 line
안녕하세요~ 이준곤(LeeChen) 입니다.
------------------------------------------------------------
[LeeChen과 함께 - 윈도우즈편 목차]
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
*3. 다이렉트 버퍼 생성 전반에 관해
4. 면의 생성과 플리핑, 비트맵 복사
5. 다이렉트 팔레트 관리
6. Lock과 Unlock, Blt, BltFast
7. 다이렉트 사운드 처리
8. 조이스틱
9. 간단한 2D 게임을 제작
------------------------------------------------------------
지난번까지 모드 셋팅에 관한것 까지 배웠습니다. 자세한글을
올리지 못하는 것에 대해서 진심으로 죄송하게 생각합니다.
워낙 초보다보니....^^;
이번에는 다이렉트 버퍼 생성과 비트맵에 관해서 알아 봅시다.
그전에 지난번에 했던 것에 대하여 잠시 살펴 보고 갑시다.
// 1차 표면(Primary Surface)만 생성하기
LPDIRECTDRAWSURFACE lpPrimary;
DDSURFACEDESC ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
lpDD->CreateSurface(&ddsd, &lpPrimary, NULL);
잉? 지난번거와는 다른데....--;
다른것 어보이예요~ 단지 함수 하나가 있죠? 메모리를 클리어
해주는 함수밖에...
LPDIRECTDRAWSURFACE는 IDirectDrawSurface의 포인터 형입니다.
쩝~ DDSURFACEDESC는 생성될 표면의 특성을 알려주는 구초체입
니다.
음... 뭐~다른것은 어뵤이죠~
지난번에 빼먹은 것이 있죠~ 뭘까요? 뭘까? 뭘까.....(끄적~끄적~)
지끔까지 생성시킨 것을 종료시켜야 겠죠~
제거하는 방법은...
lpPrimary->Release();
lpDD->Release();
요거...바로 요거랍니다. 음...간단하죠~
언제인가? 질문란을 통해 한글이나 문자를 어떻게 찍냐고 하시더
군요~ 보통 윈도우즈 API를 배우지 않고 그냥 윈도우즈 프로그램
을 하시겠다고 한다면 당연 이런쪽의 방법을 알수가 없을 겁니다.
다음 예제를 먼저 보죠~
<예제 : 다이렉트에서 글자찍기 >
HDC hdc;
if(lpDDSPrimary->GetDC(&hdc) == DD_OK)
{
Rectangle(hdc, ....);
SetTextColor(hdc, ....);
SetBkCOlor(hdc, ....);
TextOut(hdc, ....);
lpPrimary->ReleaseDC(hdc);
}
GDI를 사용하는 것이데, 이것이 무언지는 윈도우 강좌란을 참고
해서 이해를 하셨으면 합니다. 다이렉트 드로우 표면은 DC를 얻
어 GDI 함수를 사용하게 해주므로 프라머리에서 간단히 GDI함수
를 사용할수 있는 것이죠~
위 예제 함수에 대해서는 윈도우즈 API바이블을 참조 해주세요~
<소스: 위의 예제 전체 소스>
#include <windows.h>
#include <ddraw.h>
BOOL initDirectDraw(HWND hWnd);
void closeDirectDraw();
void Draw();
LPDIRECTDRAW lpDD = NULL;
LPDIRECTDRAWSURFACE lpPrimary = NULL;
.
.
// 윈도우 프로시져와 메인 함수는 생략 --;
// 공통부분이므로...
.
.
BOOL initDirectDraw(HWND hWnd)
{
HRESULT hr;
// 생성과 모드 설정
hr = DirectDrawCreate(NULL, &lpDD, NULL);
if(hr != DD_OK) return FALSE;
hr = lpDD->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN);
if(hr != DD_OK) return FALSE;
hr = lpDD->SetDisplayMode(640, 480, 8); //640*480*256 Mode
if(hr != DD_OK) return FALSE;
// 1차 표면 생성
DDSURFACEDESC ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
lpDD->CreateSurface(&ddsd, &lpPrimary, NULL);
return TRUE;
}
// DirectDraw Primary 를 소멸시킴.
void closeDirectDraw()
{
if(lpPrimary != NULL)
lpPrimary->Release();
if(lpDD != NULL)
lpDD->Release();
}
void Draw()
{
LPSTR str = "Hello!, 나에 이름은 준곤이야~";
HRESULT hr;
HDC hDC;
hr = lpDDSPrimary->GetDC(&hDC);
if(hr == DD_OK)
{
TextOut(hDC, 300, 200, str, strlen(str));
lpPrimary->ReleaseDC(hDC);
}
}
3. 비트맵
게임을 만든다면 PCX를 많이 사용했을 겁니다. 제작과 사용하기
편하다는 이유만으로....음...
그런데 윈도우즈에서는 비트맵이 존재 한다는 것은 이미 페이트
브러쉬를 통해 알고 계시죠?
윈도우즈는 비트맵 기본으로 사용하고 있습니다.
그럼...도대체 어떤 구조를 하고 있기에 비트맵을 사용할까요~
< DIB 구조 >
+-------------------+
| BITMAPFILEHEADER |
+-------------------+
| BITMAPINFOHEADER | --+--> BITMAPINFO
+-------------------+ |
| RGBQUAD | --+
+-------------------+
| Image Data |
+-------------------+
윈도우즈는 의존적 비트맵(DDB)과 장치 독립적 비트맵 (DIB)
두가지를 제공합니다. 의존적 비트맵은 일반적으로 사용하는
비트맵을 의미합니다.
// BITMAPFILEHEADER
typedef struct tagBITMAPFILEHEADER {
WORD bfType; // ASCII 값 "BM"
DWORD bfSize; // 파일 사이즈
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits; // 파일 처음부터 bitmap까지 바이트 수
} BITMAPFILEHEADER;
BITMAPFILEHEADER는 위와 같이 선언 되어 있습니다.
잉? 이것이 전부 필요 한것은 아니여요~ 여기서 필요한 것은 bfType와
bfSize인데..bfType는 이 파일이 비트맵인지를 나타냅니다. 비트맵은
16진수로 4d42이고 WORD로 "BM"을 나타냅니다.
그리구 bfSize는 파일 사이즈 인데..비트맵 파일에서
BITMAPINFOHEADER부터의 포인터를 계산하는데 사용합니다.
BITMAPFILEHEADER bmfh;
dwDibSize = bmfh.bfSize - sizeof(BITMAPFILEHEADER);
// BITMAPINFO
typedef struct tagBITMAPINFO {
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} BITMAPINFO;
보다시피 BITMAPINFOHEADER와 RGBQUAD로 구성 되어 있습니다.
// BITMAPINFOHEADER
typedef struct tagBITMAPINFOHEADER{ // bmih
DWORD biSize;
LONG biWidth; // X 크기
LONG biHeight; // Y 크기
WORD biPlanes; // Plane수 인데 항상 1
WORD biBitCount;
DWORD biCompression; // 압축 형태.
DWORD biSizeImage; // 바이트 단위로 비트맵의 크기.
LONG biXPelsPerMeter; // 미터당 수평 픽셀 수
LONG biYPelsPerMeter; // 미터당 수직 픽셀 수
DWORD biClrUsed;
DWORD biClrImportant; // 중요한 컬러수
} BITMAPINFOHEADER;
biSize는 BITMAPINFOHEADER구조의 크기
biBitCount는 픽셀당 비트 수
biClrUsed는 사용된 칼러 수를 뜻하며 값이 0이면 비트맵은
biBitCount에 대하는 최대의 컬러수를 사용합니다.
// RGBQUAD
typedef struct tagRGBQUAD {
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} RGBQUAD;
DIB의 칼런는 이 구조로 표현 되는데.. 16칼러 비트맵은
16 RGBQUAD구조,256칼러는 256 RGBQUAD구조, 예외적으로
24비트 칼러는 칼러 테이블이 없답니다.
현재 DIB가 가지고 있는 칼러수를 계산하려면....
BITMAPINFO lpBi;
...
...
if(lpBi->bmiHeader.biClrUsed != 0)
nColor = lpBi->bmiHeader.biClrUsed;
else
switch(lpBi->bmiHeader.biBitCount)
{
case 1: nColor = 2; break;
case 4: nColor = 16; break;
case 8: nColor = 256; break;
case 24: nColor = 0; break;
}
간단하죠..음..여기서 칼러 수를 계산하는 이유는 나중에
설명할 Palette생성에 필요하기 때문입니다.
(참고로 저장되는 방식은 bottom-up방식으로 저장 됩니다.)
// 이미지 데이터를 얻는 방법
lpBi + lpBi->bmiHeader.biSize + (nColor * sizeof(RGBQUAD));
으악~....출근 시간이....팔레트 부분은 생략...다음 기회에..
하도록 하죠...무려 한시간동안...궁리 끝에 끄적이는데...
다음에 강좌에 있기전에...다이렉트 엑스의 예제중에
SDK\SAMPLES\MISC\의 DDUTIL.CPP를 한번씩 분석해주세요~
많은 분들께 참고가 되었으면 하는 바램으로 적어보았습니다.
성남에서 외로움을 달래며....
이준곤(LeeChen) 드림.
#1386 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [4] 09/09 21:19 470 line
안녕하세요~ 이준곤(LeeChen) 입니다.
------------------------------------------------------------
[LeeChen과 함께 - 윈도우즈편 목차]
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
*3. 다이렉트 버퍼 생성 전반에 관해
*4. 면의 생성과 플리핑, 비트맵 복사
5. 다이렉트 팔레트 관리
6. Lock과 Unlock, Blt, BltFast
7. 다이렉트 사운드 처리
8. 조이스틱
9. 간단한 2D 게임을 제작
------------------------------------------------------------
어떻게 도움이 되는지 모르겠군요~ 최대한 쉽게 설명하려구
하는데 잘되는지는 저역시 잘 모르겠습니다. 워낙 초보이고
같은 초보 입장에서 설명을 드리는 것이니...^^;
혹시나 공부하시다가 질문이 있으시면 서슴없이 질문해
주세요~ 혹시 저에게 직접 질문을 하고 싶으시면, 가차 업
이 연락을 주세요~ 연락처라든가 메세지를 남겨 주시면
언제든....
벌써 4번째 강좌를 쓰게 되는군요~ 거의 한달이 되어 가죠?
(잉? 보름인가?)
하여간 많은 윈도우즈 게임메이커에게 도움이 되었으면 하는
마음으로 적습니다.
4. 면의 생성과 플리핑
4-1. 면의 생성
여기서 말하는 면이란 2차 면을 이야기 하는것이다. 도스
게임을 제작했던 사람이라면 이해가 빠를 텐데, 게임의
에니메이션을 구현하기 위해서는 보이는 페이지에 그림을
찍으면 깜박임이 생기는 것을 알것입니다. 이것은 수직복
귀 이전에 그림을 찍게 되면 그만큼의 딜레이로 일어나는
현상이라고 합니다. 그래서 보이지 많은 또하나의 페이지
에 찍고 수직복귀가 끝남과 동시에 한장의 그림을 쏴삭~
하면 깜박임이 생기지 않습니다.
바로 이원리가 윈도우즈라고 별수가 있겠습니까? 같은 컴
퓨터기계를 사용하고 있고 단지 OS라는 운영체제만이 바뀌
었다는 것 밖에는 차이가 없습니다.
다행이도 다이렉트는 2번째 면(2차 표면)을 만들어 플리핑
을 할수 있게 배려를 해놓았습다.
보통 보이는 면(1차 표면)과 보이지 않는 면(2차 표면)을
생성을 해두어야 사용할수가 있는데 지난번까지는 1차면
만을 생성하고 사용했었습니다.
이번부터는 어째 소스가 길어 질듯합니다. 그럼 소스를
간단히 분석을 하는 차원에서 볼까요?
LPDIRECTDRAWSURFACE lpPrimary;
LPDIRECTDRAWSURFACE lpBack;
DDSURFACEDESC ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = 1;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_FLIP | DDSCAPS_COMPLEX;
hr = lpDD->CreateSurface(&ddsd, &lpPrimary, NULL);
if(hr != DD_OK) return;
DDSCAPS ddscaps;
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
hr = lpFrontBuffer->GetAttachedSurface(&ddscaps, &lpBack);
if(hr != DD_OK) return;
지난번과 다른 것이 무엇이 있을까요? 음...(끄적~끄적~)
DDSCAPS ddscaps;
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
hr = lpFrontBuffer->GetAttachedSurface(&ddscaps, &lpBack);
if(hr != DD_OK) return;
이 부분이 추가 되었지요~ 여기서 특이한 것은 ddscaps.dwCaps =
DDSCAPS_BACKBUFFER; 입니다. 옵션은 그냥 보기만 해도 이해가 되
시죠?
DDSURFACEDESC구조체 멤버에서 dwFlags의 DDSD_BACKBUFFERCOUNT는
BackBuffer를 만들겠다는 것을 나타내고 dwBackBufferCount는
BackBuffer를 몇 개 만들것인가를 제시하게 됩니다.
일단 지금은 하나만 만들었습니다. ddsCaps의 dwCaps멤버에
DDSCAPS_FLIP 과 DDSCAPS_COMPLEX는 플립핑과 복합표면을 이용하겠
다는 것을 나타냅니다.
4-2. 면의 플리핑
복합표면이란 lpBack 이외에 하나 이상인 표면을 말합니다. 이렇게
하면 표면의 생성이 끝납다. BackBuffer 표면의 어드레스를 얻기
위해서 DDSCAPS구조체를 선언하고 IDirectDrawSurface의 멤버인
GetAttachedSurface를 호출합니다. GetAttachedSurface는
DDSCAPS에서 요구하는 특성의 표면을 얻을 수 있게 해줍니다.
여기까지가 복합 표면 즉, 2차 표면 생성의 내용이 끝납니다.
그럼 여기서 끝나느냐? 아니죠~ 당연 2차 면을 만들었으니
에니메이션이 가능한 플리핑을 해봐야 겠죠~
─────────────────────────────
HRESULT Flip(LPDIRECTDRAWSURFACE lpDDSurface,
LPDIRECTDRAWSURFACE lpDDSurfaceTargetOverride,
DDWORD dwFlags)
─────────────────────────────
설명: 플리핑 방식을 사용하여 애니메이션할 경우 비디오램
스캔 시작 어드레스를 얻어 오는 도중에 ??녕을 전환하
면 화면이 떨리게 되므로 Flip()함수는 모니터의 주사
선이 수직 재 주사 시에 화면을 갱신합니다.
첫 번째 인자인 lpDDSurface는 플립될 표면의 어드레스를
요구하는데 NULL로 설정하면 순서대로 플립됩니다.
두 번째는 플래그인데 DDFLIP_WAIT으로 세트해주면 플립이
일어날 때 까지 기다립니다. 세트해주지 않으면 바로
DERR_WASSTILLDRAWING 에러를 리턴합니다.
바로 이것을 이용하면 되는 것이죠~ 간단 간단 하게만 보이시죠
그럼 요것은 어떻게 쓸까?
hr = lpPrimary->Flip(NULL, DDFLIP_WAIT);
\\ 오프스크린 표면 생성하기
LPDIRECTDRAWSURFACE lpDDBackOff;
DDSURFACEDESC ddsd;
HRESULT hr;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwHeight = height;
ddsd.dwWidth = width;
hr = lpDD->CreateSurface(&ddsd, &lpDDBackOff, NULL);
높이(height),폭(width)에 해당한 크기의 오프 스크린을 생성
하는 것인데 지금까지 해왔던것과 별차이가 없을 겁니다.
기존의 GDI에서 본다면 하나의 메모리DC를 만드는것과 비슷합
니다.
IDirectDrawSurface는 표면의 일반적인 비트맵을 쓰기 위해서
Blt멤버 함수를 제공합니다. 이것에 대해서는 지난 3번째
강좌에서 비트맵에 관해 다루었으므로 3번째 강좌를 참조해
주세요~
DDBLTFX ddBltfx;
HRESULT hr;
ddbltfx.dwSize = sizeof(ddBltfx);
ddbltfx.dwFillColor = color;
hr = lpSurface->Blt(lpBackOffRect,
NULL,
NULL,
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
이 코드는 화면에 color의 칼러로 lpSurface의 lpBackOffRect에
명시된 영역에 채우는 역할을 합니다.
Blt의 파라미터부터 살펴보자. 첫 번째는 복사될 lpSurface의
영역(RECT구조체의 어드레스)을 나타냅니다. 두 번째는 소스의
표면의 어드레스이고 그 다음은 소스의 복사 영역, 다음은 Blt의
플래그 마지막으로 구조체는 Blt의 행위를 정해주는 DDBLTFX구조
체의 어드레스입니다.
여기서 DDBLT_COLORFILL 은 화면을 DDBLTFX 구조체에 명시된 색
으로 칠해주라는 이야기~
당연히 lpSurface의 채워질 영역 lprect만 필요로 하게 됩니다.
Blt가 다른 이유로 해서 바로 실행되지 않았을 때 혹은 실패했을
때 DDERR_WASSTILLDRAWING에러가 발생하는 데 DDBLT_WAIT은 이
에러가 발생했을 때 다시 시도합니다.
그럼 에러 코드에 대한 처리를 어떻게 할까요~
while(1)
{
hr = lpBackOff->Blt(.....);
if(hr != DDERR_WASSTILLDRAWING)
break;
}
와우~ 쉽죠~
그럼 다음은 lpBackOff에 다른 lpBackOffSrc를 복사하는 것을
알아 보죠~
lpBackOff->Blt(lpBackRect, // NULL이면 전체 영역.
lpBackOffSrc, // 소스 표면.
lpBackSrcRect, // NULL이면 전체 영역.
DDBLT_WAIT,
NULL);
lpBackOffSrc의 lpBackSrcRect에 지정된 영역에 소스의
lpBackRect에 명시된 영역을 복사합니다.
BltFast 역시 비슷합니다. 여기서는 함수의 설명으로
넘어 가겠습니다. (사실 예제를 통해서 알게 될테니...)
───────────────────────────
HRESULT BltFast(LPDIRECTDRAWSURFACE lpDDSurface,
DWORD dwX, DWORD dwY,
LPDIRECTDRAWSUFACE lpDDSrcSurface,
LPRECT lpSrcRect, DWORD dwTrans )
───────────────────────────
lpDDSurface : BltFast 함수를 사용하여 비트맵의 bit들을
복사할 목적지
dwX, dwY : 목적지 좌표
lpDDScrSurface : 복사할 비트맵
lpSrcRect : 복사할 비트맵의 영역
dwTrans : 복사할 비트맵의 특성을 설명하는 매개 변수들
이함수는 Blt함수에 비해 10%정도의 빠른 효과를 얻을 수 있습
니다만 클리핑을 사용할시 속도에는 효과가 없습니다.
4-3. 팔레트 처리
다이렉트에서도 일반 도스 게임제작에서와 같이 칼러키를 지정할
수 있습니다. 즉, 투명색을 지정하여 나타나지 않게 하는 효과를
다이렉트도 할수 있습니다. (당연 그래야 게임이 되겟죠~ ^^;)
DDCOLORKEY ddck;
ddck.dwColorSpaceLowValue = 255;// 또는 16진수로 0xff
ddck.dwColorSpaceHighValue = 255; // 상동
lpSurface->SetColorKey(DDCKEY_SRCBLT, &ddck);
보통 윈도우즈에서는 256칼라중에서 앞에 10색과 뒤에 5색을
사용하지 않습니다. 물론 윈도우즈 모드일경우에는 이것을 감안
해서 게임을 제작해야 겠죠~ 허나 독점 풀스크린 모드용 게임에서
는 보통 255번째의 흰색(255, 255, 255)를 투명 컬러로 사용합니다.
물론 이것은 사용하는 사람마다 달리 색을 정해 줄수 있습니다.
그러나 기존의 윈도우즈의 blt함수가255번 흰색을 투명컬러로
사용하기에...
그럼 이젠 스프라이트 함수를 만들수 있겠죠?
마지막으로 소스를 왕창 뿌리면서 4번째 강좌를 줄일까 합니다.
그럼 소스를 분석해 보세요~ 참 재미 있을 거예요~ ^^;
이소스는 김정(ozzy96)씨께서 작성하신 것인데 그냥 이곳에
올려 봅니다. (히히~ 저에 무지함땜시...^^;)
//==============================================================
#include <windows.h>
#include <ddraw.h>
#define BALLSIZE 40
LRESULT CALLBACK WindowFunc(HWND,UINT,WPARAM,LPARAM);
BOOL InitDDraw(HWND hwnd); // IDirectDraw생성과 표면 생성
void DestroyDDraw();
BOOL FillBuffer(LPDIRECTDRAWSURFACE lpSurface, LPRECT lprect, DWORD color);
// 지정된 영역을 color로 채워준다.
void Test(HWND hwnd);
void CreateBall(); // lpOffscreen에 붉은 원을 그려준다.
char szWinName[]="Test";
LPDIRECTDRAW lpDD = NULL;
LPDIRECTDRAWSURFACE lpFrontBuffer = NULL;
LPDIRECTDRAWSURFACE lpBackBuffer = NULL;
LPDIRECTDRAWSURFACE lpOffscreen = NULL;
POINT CirclePoint; // 원의 좌표
int cx, cy; // 볼 좌표의 증가치
int WINAPI WinMain(HINSTANCE hThisInst,HINSTANCE hPrevInst,
LPSTR lpszArgs,int nWinMode)
{
HWND hwnd;
MSG msg;
WNDCLASS WndClass;
WndClass.hInstance=hThisInst;
WndClass.lpszClassName=szWinName;
WndClass.lpfnWndProc=WindowFunc;
WndClass.style=0;
WndClass.hIcon=LoadIcon(NULL,IDI_APPLICATION);
WndClass.hCursor=LoadCursor(NULL,IDC_ARROW);
WndClass.lpszMenuName=NULL;
WndClass.cbClsExtra=0;
WndClass.cbWndExtra=0;
WndClass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);
if(!RegisterClass(&WndClass)) return 0;
hwnd=CreateWindow(
szWinName,
"Direct Draw Demo",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
HWND_DESKTOP,
NULL,
hThisInst,
NULL);
ShowWindow(hwnd,nWinMode);
UpdateWindow(hwnd);
// 다이렉트 초기화
if(!InitDDraw(hwnd)) return 0;
Test(hwnd);
while(GetMessage(&msg,NULL,0,0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
LRESULT CALLBACK WindowFunc(HWND hwnd,UINT message,
WPARAM wParam,LPARAM lParam)
{
RECT rcDes;
switch(message)
{
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
PostMessage(hwnd, WM_CLOSE, 0, 0);
return 0;
}
break;
case WM_TIMER:
cx = (CirclePoint.x >= 0 &&
CirclePoint.x <= 680 - BALLSIZE)?
cx : ~cx;
cy = (CirclePoint.y >= 0 &&
CirclePoint.y <= 440 - BALLSIZE)?
cy : ~cy;
CirclePoint.x += cx;
CirclePoint.y += cy;
SetRect(&rcDes, CirclePoint.x, CirclePoint.y,
CirclePoint.x + BALLSIZE, ptCurBall.y + BALLSIZE);
// BackBuffer를 검정색(0번 칼러)으로 지운다.
FillBuffer(lpBackBuffer, NULL, 0);
// Source Color Key를 사용할 것을 지정.
lpBackBuffer->Blt(&rcDes, lpOffscreen, NULL,
DDBLT_WAIT | DDBLT_KEYSRC, NULL);
lpFrontBuffer->Flip(NULL, DDFLIP_WAIT);
break;
case WM_DESTROY:
KillTimer(hwnd, 1);
DestroyDDraw();
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd,message,wParam,lParam);
}
return 0;
}
BOOL InitDDraw(HWND hwnd)
{
HRESULT hr;
// IDirectDraw생성과모드 설정
hr = DirectDrawCreate(NULL, &lpDD, NULL);
if(hr != DD_OK) return FALSE;
hr = lpDD->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN);
if(hr != DD_OK) return FALSE;
hr = lpDD->SetDisplayMode(640, 480, 8);
if(hr != DD_OK) return FALSE;
// FrontBuffer와 BackBuffer를 생성
DDSURFACEDESC ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = 1;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_FLIP | DDSCAPS_COMPLEX;
hr = lpDD->CreateSurface(&ddsd, &lpFrontBuffer, NULL);
if(hr != DD_OK) return FALSE;
// Back buffer의 포인터를 얻음
DDSCAPS ddscaps;
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
hr = lpFrontBuffer->GetAttachedSurface(&ddscaps, &lpBackBuffer);
if(hr != DD_OK) return FALSE;
// 오프스크린 생성
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
ddsd.dwHeight = BALLSIZE;
ddsd.dwWidth = BALLSIZE;
hr = lpDD->CreateSurface(&ddsd, &lpOffscreen, NULL);
if(hr != DD_OK) return FALSE;
return TRUE;
}
// 오프스크린에 붉은 색 공을 그리고 칼러키를 지정
voidCreateBall()
{
FillBuffer(lpOffscreen, NULL, 0xff);
HBRUSH hbrush, hold;
HDC hdc;
HRESULT hr;
if(hr = lpOffscreen->GetDC(&hdc) == DD_OK)
{
hbrush = CreateSolidBrush(RGB(255, 0, 0));
hold = SelectObject(hdc, hbrush);
Ellipse(hdc, 0, 0, BALLSIZE, BALLSIZE);
SelectObject(hdc, hold);
lpOffscreen->ReleaseDC(hdc);
}
// Set Color key
DDCOLORKEY ddck;
ddck.dwColorSpaceLowValue = 0xff;
ddck.dwColorSpaceHighValue = 0xff;
lpOffscreen->SetColorKey(DDCKEY_SRCBLT, &ddck);
}
void Test(HWND hwnd)
{
SetTimer(hwnd, 1, 10, NULL);
ptCurBall.x = 300;
ptCurBall.y = 200;
xcin = cy = 2;
CreateBall();
}
BOOL FillBuffer(LPDIRECTDRAWSURFACE lpSurface, LPRECT lprect,
DWORD color)
{
DDBLTFX ddbltfx;
HRESULT hr;
ddbltfx.dwSize = sizeof(ddbltfx);
ddbltfx.dwFillColor = color;
hr = lpSurface->Blt(lprect, NULL, NULL,
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
return hr == DD_OK;
}
void DestroyDDraw()
{
if(lpBackBuffer != NULL) lpBackBuffer->Release();
if(lpFrontBuffer != NULL) lpFrontBuffer->Release();
if(lpOffscreen != NULL) lpOffscreen->Release();
if(lpDD != NULL) lpDD->Release();
}
//==========================================================
사실 실제 게임에 쓸수 있는 소스입니다. 그러나 이미지를
가지고 하지만 않았을뿐 다른 부분이 없습니다.
원을 그리고 한다고 이걸 어디써~ 하고 생각하심은 안됩니
다. 음..소스를 제가 직접 제작하지 못해서 죄송하게 생각
합니다. 앞으로 더욱 좋은 내용으로 적어 보겠습니다.
많은 분들께 참고가 되었으면 하는 바램으로 적어보았습니다.
성남에서 외로움을 달래며....
이준곤(LeeChen) 드림.
#1389 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [5] 10/07 00:22 254 line
////////////////////////////////////////////////////////////
안녕하세요~ 이준곤(LeeChen) 입니다.
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
강좌가 무척이나 늦어 졌죠? 이 글을 읽어 주시는 많은 독자분들
과 저에게 아낌 없는 성원을 보내 주신 분들께 진심으로 감사드
립니다.
그동안 보내주신 질책과 격려를 해주신 덕분에 힘을 얻어 계속적
인 강좌를 해 나가기로 했습니다. (당연한 소리를....^^;)
------------------------------------------------------------
[LeeChen과 함께 - 윈도우즈편 목차]
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
*3. 다이렉트 버퍼 생성 전반에 관해
*4. 면의 생성과 플리핑, 비트맵 복사
*5. 다이렉트 팔레트 관리
6. Lock과 Unlock, Blt, BltFast
7. 다이렉트 사운드 처리
8. 조이스틱
9. 간단한 2D 게임을 제작
------------------------------------------------------------
5. 다이렉트 파레트 관리
다이렉트를 써보신 분들은 8비트(256 color) 이상을 지원한다는
것을 알고 있을 겁니다. 또한 상위 컬러 보다도 8비트기능이 무
척이나 강하다고 할수 있더군요~
당연 많은 게임들이 8비트를 지원 하고 아직까지는 8비트에서
게임을 제작해도 무난하기 때문이죠~
윈도우즈 게시란을 보니 한동안 16비트 칼라에 대해 논의 하고
있으시더군요~ (으...--; )
다이렉트에서 파레트를 처리하는 과정을 살펴 보면 다음과 같
은 도식표가 제작이 되어 집니다.
+---------------------------------------------------------+
| 팔래트 생성 (DDLoadPalette) |
+---------------------------------------------------------+
|
+---------------------------------------------------------+
| 생성된 팔레트를 전면 버퍼에 셋팅(SetPalette) |
+---------------------------------------------------------+
|
+---------------------------------------------------------+
| 이곳에서는 이미지가 찍히는 처리가 되겠죠~ |
| 당연 스프라이트가 있는 이미지를 뜻하는 것이죠~ |
+---------------------------------------------------------+
|
+---------------------------------------------------------+
| 투명색을 설정해야 겠죠~ (DDSetColorKey) |
+---------------------------------------------------------+
< 팔레트 셋팅 모식도 >
어때요? 모식도만 보고도 감이 오시는 분도 계시죠? (음...)
그렇다면 이강좌를 읽어 보실필요 없겠군요~ (하하하~ ^^;)
다이렉트의 팔레트 객체는 여러개를 생성할 수 있습니다.
무엇을 사용하면 될까요? 지금까지 사용할때 생성할때는 어떤
스타일의 함수를 사용했죠?
요거 CreatePalette라구요~ 당근이죠~대충 감으로 마추시는
분도 계시군요~ 그렇다면 CreatePalette로 생성된 팔레트는
어떤 함수를 이용해서 선택되어 질까요?
아하~ 근방 마추시는 군요~ SetPalette()함수!
읽어 들인 비트맵의 팔레트 정보를 팔레트 엔트리에 채우고
다이렉트 드로우의 API인 CreatePalette()함수를 이용해서
팔레트를 생성하면 됩니다.
일단 팔레트를 읽어 들일때는
LPDIRECTDRAWPALETTE lpPalette;
.....
.....(어쩌고 저쩌고...)
lpPalette = DDLoadPalette(lpDD, "Palette");
//여기서 "Palette"는 Palette.bmp를 뜻합니다.
.....
.....(어쩌고 저쩌고...)
그렇다면 이쯤에서 CreatePalette() 함수는 어떤 것인가?
도대체 어떤 것이길래? 궁금하시죠~ 한번 살펴 보죠~
=======================================================
HRESULT CreatePalette(
LPDIRECTDRAW lpDD,
DWORD dwFlags,
LPPALETTEENTRY lpColorTable,
LPDIRECTDRAWPALETTE FAR *lplpDDPlaette,
lUnknown FAR *pUnkOuter )
=======================================================
함수 인자 설명 :
lpDD : DirectDraw 객체에 대한 포인터
dwFlags : 컬러 엔트리의 포멧을 다이렉트에 전달하기
위한 매개 변수
lpColorTable : RGB엔트리에 대한 매개변수
pUnkOuter : 보통 NULL값을 가짐
DDLoadPalette()함수 내의 CreatePalette()함수의 dwFlags는
DDPCAPS_8BIT로 256개의 색상 정보를 생성합니다. 만약 16
비트로 하고자 한다면 8BIT대신 16BIT로 주시면 되겠죠~
일반적으로 전면 버퍼의 팔레트를 관리하며
DDSCL_EXCLUSIVEMODE플래크와 DDSCK_FULLSCREEN 플래그 설정
되어 있다면 GDI팔레트 보다 빠릅니다.
다음은 다이렉트 소스에 있는 파레트 처리하는 함수의 소스
입니다. 필자가 따로 이부분의 소스가 없으므로 있는 것으로
대체 하겠습니다. 보시는 분들께 양해 부탁드립니다.
//
// DDLoadPalette 함수
//
// 비트맵의 파레트를 다이렉트 드로우에 생성하는 함수
//
// 만약 파레트 와일이 없거나 NULL이면 생성을 디폴트로 합니다.
// ( 332 palette ? )
//
extern "C" IDirectDrawPalette * DDLoadPalette(IDirectDraw *pdd,
LPCSTR szBitmap)
{
IDirectDrawPalette* ddpal;
int i;
int n;
int fh;
HRSRC h;
LPBITMAPINFOHEADER lpbi; // 비트맵 헤더
PALETTEENTRY ape[256]; // 256 구조를 가지겠죠?
RGBQUAD * prgb; // RGB 엔트리
//
// 일단은 디폴트 파레트로 맞구고 보자~ ( 332 palette )
//
for (i=0; i<256; i++)
{
ape[i].peRed = (BYTE)(((i >> 5) & 0x07) * 255 / 7);
ape[i].peGreen = (BYTE)(((i >> 2) & 0x07) * 255 / 7);
ape[i].peBlue = (BYTE)(((i >> 0) & 0x03) * 255 / 3);
ape[i].peFlags = (BYTE)0;
}
//
// 만약에 비트맵 화일이 존재한다면 당연 읽어야 지!
//
if (szBitmap && (h = FindResource(NULL, szBitmap, RT_BITMAP)))
{
lpbi = (LPBITMAPINFOHEADER)LockResource(LoadResource(NULL, h));
prgb = (RGBQUAD*)((BYTE*)lpbi + lpbi->biSize);
// 파레트 구조를 파악하는 부분이 겠죠~
if (lpbi == NULL || lpbi->biSize < sizeof(BITMAPINFOHEADER))
n = 0;
else if (lpbi->biBitCount > 8)
n = 0;
else if (lpbi->biClrUsed == 0)
n = 1 << lpbi->biBitCount;
else
n = lpbi->biClrUsed;
//
// 비트맵 칼라의 구조가 RGB구조가 아니고 BGR이구조이므로
// 바꿔 주어야 한다.
//
for(i=0; i<n; i++ )
{
ape[i].peRed = prgb[i].rgbRed;
ape[i].peGreen = prgb[i].rgbGreen;
ape[i].peBlue = prgb[i].rgbBlue;
ape[i].peFlags = 0;
}
}
else if (szBitmap && (fh = _lopen(szBitmap, OF_READ)) != -1)
{
BITMAPFILEHEADER bf;
BITMAPINFOHEADER bi;
_lread(fh, &bf, sizeof(bf));
_lread(fh, &bi, sizeof(bi));
_lread(fh, ape, sizeof(ape));
_lclose(fh);
if (bi.biSize != sizeof(BITMAPINFOHEADER))
n = 0;
else if (bi.biBitCount > 8)
n = 0;
else if (bi.biClrUsed == 0)
n = 1 << bi.biBitCount;
else
n = bi.biClrUsed;
//
// 비트맵 칼라의 구조가 RGB구조가 아니고 BGR이구조이므로
// 바꿔 주어야 한다.
//
for(i=0; i<n; i++ )
{
BYTE r = ape[i].peRed;
ape[i].peRed = ape[i].peBlue;
ape[i].peBlue = r;
}
}
// 256색을 초기화 한다.
pdd->CreatePalette(DDPCAPS_8BIT, ape, &ddpal, NULL);
return ddpal;
}
※ 풀스크린과 윈도우즈 모드의 팔래트 사용시 차이점
1. 독점 모드 (Full Screen Mode)
풀 스크린(독점 모드)의 프로그램에서는 물리적 팔레트의
RGB의 첫번째 값과 마지막 값인 검은색과 흰색을 제외한 모
든 색을 제어 할수 있습니다. 단 여기서 앞의 검정색과 맨끝
의 흰색은 반드시 이색이여야 합니다.
앞의 색과 뒤의 흰색을 바꿀수도 있습니다. 이런 예외 방법
을 사용해도 되지만 어떤 그래픽 카드에서는 이러한 문제로
파레트가 깨지는 문제가 발생 될수도 있습니다.
2. 윈도우즈 모드 (Normal Screen Mode)
윈도우즈 모드에서는 물리적 팔레트의 앞의 10개와 뒤의 10개
의 색은 이미 예약이 되어있습니다. 누가 예약 했을 까요?
(그렇다면 프로그래머가 예약을 미리 하면 안되남? ^^;)
이것은 윈도우즈라는 운영체제가 사용하고 있습니다. 이런것
때문에 그아무리 호화 스러운 색을 써도 이부분을 사용해서는
안되므로 윈도우즈 창이 색이 변하지 않고 플레이가 되는 것
입니다. 만약 윈도우즈가 쓰는 색을 침범할수도 있지만 될수
있는한 침범을 하지 않는 것이 보기가 좋지 않을 까요?
어째 오늘도 부실한 내용만을 설명한 샘이 된것 같아 허전하군
요~ 다음에는 더욱더 알찬 내용을 가지고 강좌를 해보겠습니다
질문있으시면 가차 없이 질문해주시면 정성것 답변해드리겠습
니다.
지금까지 무소속 성남의 별땅 하늘땅 지구땅의 이준곤(LeeChen)
이였습니다.
컴퓨터의 세계는 당신의 꿈을 실현해
무한한 가능성을 보여 줄수 있습니다.
- LeeChen -
#1390 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [6] 10/07 12:30 183 line
안녕하세요~ 이준곤(LeeChen) 입니다.
지난 시간에는 다이렉트의 팔레트 관리에 관해서 알아 보았습니다.
이번 시간에는 Lock과 UnLock을 배워보겠습니다. 보통 메모리를
사용하는데 있어서 자신이 사용하고 있는 동안 사용하고 있는 범위
에 대해서는 어떠한 다른 작업의 침범이 있어서는 안됩니다.
만약 이런 것이 허용된다면 메모리 에러나 오버플로 현상으로 인해
시스템이 다운현상이 일어납니다.
( 필자는 아직까지는 이런일이 없었으므로 실제로 오버 플로우나
시스템 에러 현상이 있는지 확인을 해보시기 바랍니다. 이것 역시
좋은 경험이 되니까요~ ^^;)
다시 본론으로 들어와서 앞에서 우리는 비트맵에 대해서 배웠으며
비트맵을 찍는 방법에 대해서도 배웠습니다. 또한 팔레트 를 처리
하는 방법을 배웠습니다. 이정도라면 어느정도 게임을 제작할 수
있지만 어디 이건만 가지고 가능하겠습니까~
Chap 6-1. Lock/Unlock Function
DirecDrawSurface는 비디오 메모리를 사용하거나 시스템 메모리를
사용할 수 있는데 비디오 메모리가 부족할 경우 시스템 메모리를
사용하게 됩니다.표면을 어디에 생성할 것인가를 지정하지 않으면
비디오 메모리에 표면이 생성됩니다.
비디오 메모리를 사용할 경우에 Surface는 비디오 카드와 직접 거래
를 하게 됩니다. 그러므로 전면 Surface는 항상 비디오 메모리에 존
재하게 됩니다. 플리핑을 하게 된다면 전면 Surface와 후면 Suface
역시 비디오 메모리에 존재 하게 됩니다.
비디오 Surface를 사용할 경우에는 전면 Surface보다 후면 Surface는
커서는 않됩니다. 그러나 시스템 메모리를 사용할 경우 이러한 제한
은 없습니다.
지금까지는 사실 비디오 메모리를 사용하는 방법만을 언급했습니다.
오늘의 주제가 주제인 만큼 시스템 메모리에서 비디오 메모리로
전송하는 방법을 이야기 하려 합니다.
이방법을 알게 되면 자체 스프라이트 포맷을 사용했던(기존의 도스용
게임)의 포맷을 그대로 윈도우즈로 포팅할수 있겠죠? ^^;
이미지를 표면으로 복사하기 위해서는 비디오 메모리를 얻어야 하는데
비디오 메모리 내에 존재하는 DirectDrawSurface의 경우 다이렉트의
Lock를 사용합니다. 사실 Lock는 일반 API에도 존재 하므로 이것을
잘못 이해 하시면 안됩니다.
표면으로 이미지를 전송할 때 비디오 메모리의 내용이 소실되지 않게
하기 위해서 다이렉트는 Lock와 Unlock의 실행 사이에 Win16Lock을
사용합니다. 이함수는 윈도우즈에서 사용하는 Global Systemm Lock입
니다. 바로 GDI가 Video Display Driver sk 다른 16비트 컴포넌트를
사용하기 위한 Lock 라고 보시면 됩니다.
이쯤해서 그런 그렇게 떠들어 대는 Lock은 도대체 어떤 구조일까?
하시는 분이 계시겠죠? 어디 한번 살펴 봅시다.
==========================================================
HRESULT Lock( LPDIRECTDRAWSURFACE lpDDSurface,
LPRECT lpDestRect,
LPDDSURFACEDESC lpDDSurfaceDesc,
DWORD dwFlags,
HANDLE hEvent)
==========================================================
함수 인자 설명:
lpDDSurface : LPDIRECTDRAWSURFACE 구조체에 대한 포인터
lpDestRect : 표면 영역중 lock되는 영역을 나타내는 RECT구조체 포인터
lpDDSurfaceDesc : LPDDSURFACEDESC 구조체에 대한 포인터
dwFlags : DDLOCK_SURFACEMEMORYPTR, DDLOCK_EVENT,
DDLOCK_WAIT의 세 가지 중 하나의 플래그 설정
만약 blt중에 lock을 시도하면 WASSTILLDRAWING에러가
발생하는데 이때는 플래그를 DDLOCK_WAIT로 세팅한다.
hEvent : 시스템 이벤트에 대한 핸들
다이렉트로 메모리를 전송하는 방법에는 두가지 종류가 있습니다.
1. 한 번에 한바이트씩 전송
2. 뱅크를 사용하여 한번에 64K씩 데이터를 전송
이방법은 DDSCAPS_BANKSWITCHED 플래그를 사용합니다.
만약 성공하지 못하면 page fault가 발생됩니다.
자~ 이번에는 앞에서 배운 것을 토데로 1번 방식을 이용한 함수를
만들어 봅시다.
HRESULT ddrval;
DDSURFACEDESC ddsd;
LPSTR lpBits;
LPSTR lpSrc;
int I;
ddsd.dwSize = sizeof(ddsd);
ddrval = lpPrimary->Lock(NULL, &ddsd,, 0, NULL);
lpBits == (LPSTR) ddsd.lpPrimary;
for(i=0; I<480; I++)
{
memory(lpBits, lpSrc, 640);
lpBits += ddsd.lPitch;
lpSrc += 640;
}
ddrval = lpPrimary->Unlock(NULL);
음...간단하죠? 앞에서도 이야기 했듯이 blt되는 동안 lock될 수 없으며
비디오 메모리의 표면은전면 버퍼 보다 클수 없고 또한 화면 전환을
위해서 Flip하는 동안 후면 버퍼를 lock할수 없습니다.
Chap 6-2. Blt / BltFast Function
다이렉트는 비트맵을 찍기위해서 Blt함수와 BltFast가 있습니다. 이두
함수의 특징은 Blt는 클리핑하는데 적격입니다. 그렇다고 BltFast는
클리핑을 못하느냐? 그건 아닙니다. 보통 Blt함수 보다 BltFast함수가
속도가 10%정도 빠릅니다. 그러나 클리핑같은 처리를 하게 되면 속도
에 대한 효과는 볼수 없습니다. 이렇게 된다면 두함수의 기능은 같은
것이나 다름 없나보죠?
Blt 구조는 단순하고 기존의 GDI의 Blt함수과 비슷하므로 BltFast만을
분석하겠습니다. BltFast를 참조해서 Blt 함수를 분석해보세요~
===========================================================
HRESULT BltFast(LPDIRECTDRAWSURFACE lpDDSurface,
DWORD dwX,
DWORD dwY,
LPDIRECTDRAWSURFACE lpDDSrcSurface,
LPRECT lpSrcRect,
DWORD dwTrans)
===========================================================
함수 인자 설명 :
lpDDSurface : BltFast함수를 사용하여 비트맵의 bit 들을 복사할 목적지
dwX,dwX : 목적지 x, y좌표
lpDDSrcSurface : 복사할 비트맵
lpSrcRect : 복사할 비트맵의 영역
dwTrans : 복사할 비트맵의 특성 매개 변수들
함수를 사용하는 방법은 다음의 예제를 사용해 보았습니다.
클리핑이 되도록 처리 하는 스프라이트 찍는 함수의 주된 내용입니다.
제가 상용게임에 사용하고 있는 실제 스프라이트 함수의 소스입니다.
RECT rc;
int tempxs, tempys;
HRESULT ddrval;
rc.left = 0;
rc.top = 0;
rc.bottom = ys;
rc.right = xs;
x-=xs/2;
y-=ys;
tempxs = x+xs;
tempys = y+ys;
if (x > 639 || y > 479) return DD_OK;
if (tempxs <= 0 || tempys <= 0) return DD_OK;
if (x < 0) { rc.left -= x; x=0; }
else if (tempxs > 639) rc.right -= (tempxs - 639);
if (y < 0) { rc.top -= y; y=0; }
else if (tempys > 479) rc.bottom -= (tempys - 479);
ddrval = lpSurface->BltFast(x, y, lpDS, &rc,
DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);
return ddrval;
단순하고 간단하죠~ 무척이나 쉽게 짜져 있는 소스인데 별도의
설명이 필요 없겠죠?
더욱 자세 한 것은 제가 앞의 연재에서 기재했던 중에 참고서적
을 참고하세요~ 그러면 많은 도움이 되실 겁니다.
이것으로 6회 Lock/Unlock, Blt/BltFast 강좌를 마치도록 하겠습
니다.
앞으로 몇개의 강좌를 마치고 3차원 강좌를 이어서 해보이겠습니
다. 다이렉트 3D가 5.0에서 무척이나 빨라져서 이젠 누구나 3차원
게임을 즐기고 제작할 수 있는 수준이라 다이렉트를 이용해서
3차원 게임을 제작해 보도록 하겠습니다.
성남의 무소속 별땅 하늘땅 지구땅의 이준곤(LeeChen) 이였습니다.
당신의 무한한 잠재력을 컴퓨터는 원한다.
당신의 상상 속의 꿈을 억제하지말고 지금
이순간 실현으로 옮겨라~ 바로 컴퓨터로
말이다.
- LeeChen -
#1399 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [7] 10/19 14:38 271 line
////////////////////////////////////////////////////////////
안녕하세요~ 이준곤(LeeChen) 입니다.
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
안녕하세요~ 한동안 시간을 핑계삼아 지연되고 있는 윈도우즈
게임 강좌를 성원해주시는 많은 분들께 진심으로 감사드리며
앞으로도 계속적으로 강좌를 하겠습니다.
------------------------------------------------------------
[LeeChen과 함께 - 윈도우즈편 목차]
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
*3. 다이렉트 버퍼 생성 전반에 관해
*4. 면의 생성과 플리핑, 비트맵 복사
*5. 다이렉트 팔레트 관리
*6. Lock과 Unlock, Blt, BltFast
*7. 다이렉트 사운드 처리
8. 다이렉트 조이스틱 처리
9. 간단한 2D 게임을 제작
------------------------------------------------------------
Chap 7-1. Direct Sound
벌써 7번째 다이렉트 사운드를 처리할 수 있는 시간이 되었군요~
다이렉트 사운드는 도스 시절의 사운드는 DMA전송을 사용해서
멀티사운드등을 처리했던 것으로 기억하고 있습니다.(그런가??)
그래도 가끔 메모리 충돌현상으로 인해 더욱 좋은 사운드 라이브
러리를 누가 만드는가가 관건이었던 시절이 있었죠?
그러나 윈도우즈의 특징이 하드웨어를 제어하는데 있어 시간적인
투자를 할필요가 없겠죠? (^^; )
다이렉트 사운드는 기존의 도스용 라이브러리의 경우 함수들이
추가될 경우 새로운 라이브러리가 이전에 개발한 프로그램과
제대로 호환이 안되거나 일정한 표준이 없어 우왕자왕했습니다.
그러나 Component Object Model(COM)을 지원하므로서 이러한
문제는 문제가 되지 않습니다.
다이렉트 사운드는 IDirectSound와 IDirectSoundBuffer로 구성
되어 있습니다. 다이렉트 버퍼는 1차 사운드 버퍼(Primary
Sound)와 2차 사운드 버퍼(Secondary Sound Buffer)로 나누어
집니다. 1차 사운드 버퍼는 2차사운드 버퍼의 버퍼를 밍싱하여
출력하며 2차 사운드 버퍼는 실제 게임에 사용되는 오직 하나의
사운드만을 담고 있습니다. 이해가 되는지 모르겠군요?
2차 사운드 버퍼는 사운드 버퍼의 메모리보다 큰 메모리 영역을
사용할 수 있으며 사운드 카드 내의 메모리보다 큰 메모리의
영역을 사용할 경우 시스템 메모리를 사용하게 된다. 또한 2차
사운드 버퍼의 모든 음향들은 1차 사운드 버퍼로 보내기 전에
자동으로 믹싱되어 보내지게 됩니다.
모식도로 표현하면
+--------------------------------------------------+
| +--------------------+ |
| | 1차 사운드 버퍼 | |
| +--------------------+ |
| +--------------------+ |
| | 2차 사운드 버퍼 | |
| +--------------------+ |
| |
| +--------------------+ |
| | 2차 사운드 버퍼 | |
| +--------------------+ |
| ..... |
| +--------------------+ |
| | 2차 사운드 버퍼 | |
| +--------------------+ |
+--------------------------------------------------+
<그림 7-1>
그림 가지고는 이해 하기 힘들다구요? 한마디로 하나의
1차 사운드 버퍼에 여러개의 2차 사운드 버퍼가 존재가
가능하다는 것을 보여 주는 모식도 입니다.
다이렉트 사운드는 다음과 같은 과정으로 하나의 사운드
를 출력 하게 됩니다.
1) 다이렉트 사운드 객체 생성
2) 필요한 사운드의 2차 버퍼 생성
3) 생성된 버퍼에 음향 데이타를 전송
(이때 lock와 Unlock를 사용합니다.)
4) 2차 사운드 버퍼에 있는 음향들을 출력
아주 간단한 구조를 가지고 있죠? 이찌 보면 지금까지
배웠던 이미지 출력과도 비슷하다고 볼수 있네요?
그럼 사운드가 출력하기 까지의 모식도를 보도록 하죠!
+----------+ +--+
| 2차 버퍼 | --> | |
+----------+ |메| +--------------+
....... |모| +--------+ | |
+----------+ |리|-->|1차 버퍼| ->|스피커로..쨔쟌|
| 2차 버퍼 | --> | | +--------+ | |
+----------+ |믹| +--------------+
+----------+ |싱|
| 2차 버퍼 | --> | |
+----------+ +--+
지금까지 알아본 내용을 토데로 실제 사운드 관련 코딩을
해봅시다.
1. 다이렉트 사운드 생성
LPDIRECTSOUND lpDs;
HWND hwnd;
HRESULT dsrval;
dsrval = DirectSoundCreate(NULL, &lpDs, NULL);
if(dsrval != DS_OK)
return FALSE; // 다이렉트 사운드 생성의 실패시
lpDs->SetCooperativeLevel(hwnd, DDSSCL_NORMAL);
여기까지가 사운드 객체의 생성하는 코드였습니다.
함수는 앞에서 배운 다이렉트 함수 구조와 다른것이 없으
므로 함수설명을 생략하겠습니다.
자~ 이번에는 2차 사운드 버퍼를 생성해 봅시다. 앞에서
장황하게 설명만 해놓고 2차 버퍼가 무척 중요하건 것
같은 생각으로 들지만 살펴 보면 별거 아니네? 하실 겁
니다.
2. 필요한 데이타의 2차 버퍼 생성
LPDIRECTSOUND lpDs;
LPPCMWAVEFORMAT pcmwf;
LPDIRECTSOUNDBUFFER lpDsb;
DSBUFFERDESC dsbd = {0};
dsbd.dwSize = sizeof(dsbd);
dsbd.dwFlags = DSBCAPS_CTRLDEFAULT;
dsbd.dwBufferByte = 30000;
dsbd.lpwfxFormat = (LPWAVEFORMATEX)&pcmwf;
dsrval = lpDs->CreateSoundBuffer(&dsbd, lplpDsb, NULL);
if(dsrval != DS_OK)
return FALSE; // 당연 실패 했을 경우겠죠?
여기까지가 2차 사운드 버퍼를 생성하는 코드 입니다.
어떻습니까? 그리 어렵지는 않죠? 2차 사운드는 두종류로
나누어 집니다. 어떤 걸까요?
바로 Static Buffer와 String Buffer로 나누어 집니다.
보통 짧은 소리는 Static Buffer에 답겨 지고 여러번 반복
출력 하기 위해 사용되어 집니다. 긴 소리는 String
Buffer에 답겨 지게 되며 2~3회 반촉 출력 하기 위해 사용되
어집니다.
그렇다면 지금까지 앞의 1)과 2)에 해당된 것은 구현이 된
상태고 음향 데이타를 생성된 버퍼에 전송하는 것을알아
봅시다.
3. 생성된 버퍼에 음향 데이타를 전송
LPDIRECTSOUNDBUFFER lpDsb;
DWORD dwOffset = 0;
DWORD dwLength = 30000;
LPVOID lpvPtr;
DWORD dwBytes;
dsrval = lpDsb->Lock(dwOffset, dwLength, &lpvPtr, &dwBytes,
NULL, NULL, 0);
if(dsrval != DS_OK)
return FALSE;
// 이부분은 어째? 어느 부분과 비슷하죠?
// 지난 번에 배운 lock과 unlock를 참조 하세요~
LPBYTE lpbSoundData;// 전송할 음향 데이타
LPVOID lpvPtr;
DWORD dwBytes;
CopyMemory(lpvPtr, lpbSoundData, dwBytes);
dsrval = lpDsb->Unlock(lpvPtr, dwBytes, NULL, 0);
if(dsrval != DS_OK)
return FALSE;
자~ 여기까지가 일단은 만들어진 사운드를 다이렉트 버퍼에
전송 해지게 되었습니다. 어떻습니까? 지금까지 배운 것들이
모두 비슷비슷하죠?
4. 2차 사운드 버퍼에 있는 음향들을 출력
LPDIRECTSOUNDBUFFER lpDsb;
lpDsb->Play(0, 0, DSBPLAY_LOOPING);
// 기타 여러 처리들
.......
// 나중에 멈추고 싶으면...
lpDsb->Stop();
출력하는 것이 이정도면 어느정도 이해가 되셨겠죠?
함수가 그리 어렵지 않기 때문에 설명보다는 코딩된 것이
이해 하기가 어렵지 않을 겁니다.
그렇다고 여기서 사운드 처리가 끝나느냐? 그건 아니죠!
우리가 게임을 하면서 마치 사람이 오른쪽에서 걸어오는
착가을 느끼거나~ 왼쪽에서 오른 쪽으로 사라져 가는
비행기 소리~ 또는 저멀리서 바로 앞으로 날아 오는 무언
가의 물체 소리를 우리는 어떻게 구현을 할것인가?
바로 이러한 문제는 아주 쉽습니다. 보륨조절로 인해 작게
들렸다 크게 들리면 저멀리서 가까이 오는 듯하는 효과를
볼수 있습니다. 그리고 오른쪽 스피커를 크게 했다가 점점
왼쪽 스피커로 소리를 나오게 하면 마치 우리는 3차원
음향을 듣는 듯한 착각을 하게 됩니다.
이러한 효과는 어떻게 얻는냐? 그것이 문제군요? (^^;)
그러나 이글을 보는 분은 이미 알고 있는 분도 계실테고
어라~ 이런 또 뭐야~ 하는 분도 있을 겁니다.
이럴때를 위해 다이렉트 사운드는 이러한 함수를 제공합니
다.
SetVolume(lpDS, DWORD, dwVolume);
// 요건 함수를 호출하여 원하는 볼륨으로 소리나게 하는
// 함수 입니다.
SetPan(lpDs, DWORDm dwPan);
// 좌우의 사운드 밸런스를 조절하는 기능을 하는 함수
SetFrequency(lpDS, LPDWORD, lpdwFrequency))
// 소리의 피치를 조정합니다. dwFrequency 값이 높을
// 수록 피치가 증가합니다. 만약 조정하기 전에 현재
// 피치를 알기 위해서는 GetFrequency()함수를 호출
// 해서 값을 얻어 오면 됩니다.
SetCurrentPosition();
// 이함수는 현재 데이타의 위치를 알아 내는 함수 입니다.
// 데이타의 끝나는 부분을 체크할 때 유용하게 사용되어
// 지겠죠?
음..여기까지 설명을 하면서 어렵게 느껴지지는 않나
싶은 우려를 하면서 여기까지가 사운드를 다~배웠어요~
다이렉트 엑스를 공부하거나 윈도우즈를 공부하면서
어려움이 있거나 질문있으시면 가차 없이 질문을 해주세요~
그럼 제 7회 강좌 다이렉트 사운드에 대해서 배워 보았습
니다. 그럼 다음 기회에 더욱 더 좋은 내용으로 만나길
바라면서...
성남에서 조용한 주말을 보내면서 글을 적어 보았습니다.
- 이준곤 (LeeChen) -
#1400 서성칠 (ssc7 )
[강좌] <LeeChen> 윈도우 게임제작 [8] 10/19 16:03 131 line
////////////////////////////////////////////////////////////
안녕하세요~ 이준곤(LeeChen) 입니다.
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
안녕하세요~ 한동안 시간을 핑계삼아 지연되고 있는 윈도우즈
게임 강좌를 성원해주시는 많은 분들께 진심으로 감사드리며
앞으로도 계속적으로 강좌를 하겠습니다.
------------------------------------------------------------
[LeeChen과 함께 - 윈도우즈편 목차]
*1. 다이렉트 전반에 관해서...
*2. 다이렉트 생성과 프로세서 독점, 모드 셋팅
*3. 다이렉트 버퍼 생성 전반에 관해
*4. 면의 생성과 플리핑, 비트맵 복사
*5. 다이렉트 팔레트 관리
*6. Lock과 Unlock, Blt, BltFast
*7. 다이렉트 사운드 처리
*8. 다이렉트 조이스틱 처리
9. 간단한 2D 게임을 제작
------------------------------------------------------------
Chap 8. Direct Input
게임을 즐기다 보면 오락실 게임만 못하다는 핑찬이 생기는 게임
들이 있죠? 특히 액션이나 슈팅같은 게임을 오락실에서 받은
감동을 PC에서 하다 보면 그냥......
이런점을 조금이나마 느끼기 위해서 조이스틱이라는 것을 사용하
므로 약간의 감동을 느낄수 있다고 봅니다.
도스용 게임이 조이스틱을 지원하지만 사실 키보드나 마우스의
기능에 더욱 의존하던 것이 사실입니다.
만약 이글을 읽는 분이 조이스틱에 관한 정보가 없거나 모르는
분은 아마도 조금은 도움이 될것이라고 보입니다.
일단 처음 프로그램을 시작할때 조이스틱이 있는지? 아님 다른
무언가가 존재 하는지? ( 여기서 무언가라는 것은 입력 장치를
뜻하는 것입니다.)
바로 있때 지원하는 함수는 joyGetCaps() 라는 것인데 다음과
같이 사용합니다.
MMRESULT rc;
JOYCAPS jc;
rc = joyGetDevCaps(joy_id, &jc, sizeof(jc));
if(rc == JOYERR_NOERROR)
{
// 여기서 원하는 장치 처리를 하면 되겠죠~
}
여기서 조이스틱에 대한 정보를 얻었다면 조이스틱에 x, y축에
관한 이동 관련값을 얻거나 셋팅을 해야 겠죠?
버튼수도 정해 주는 것은 당연한 것이고 아날로그 조이스틱인지?
티지탈 조이스틱 인지 등등 역시 지원하는 것에 대해 명시를
해주어야 하겠습니다.
JOYINFOEX joy;
joy.dwSize = sizeof(joy);
joy.dwFlag = JOY_RETURNALL;
rc = joyGetPosEx(joyid, &joy);
if(rc == JOYERR_NOERROR)
{
// 조이스틱의 정보 값 처리
}
그렇다면 여기서 조이스틱 정보 값이란? 무얼까요?
바로 다음과 같은 정보값을 읽어 옵니다.
1) x, y 각축의 최대 최소 값의 범위에 대한 정보
2) 입력에 대한 시간 설정값, 즉 일정한 시간 낸에 들어온
조이스틱의 입력을 처리하기 위해서 설정한 시간에 대한
정보
3) 조이스틱의 조정에 대한 정보
4) 조이스틱 레지스트 정보
JOYREGUSERVALUES uv;
DWORD type;
DWORD cb;
HKEY hkey;
cb = sizeof(uv);
if(RegOpenKey(HKEY_LOCAK_MACHINE, szRegCfgKey, &hkey))
{
if(!RegQueryValueEx(hkey, REGSTR_VAL_JOYUSERVALUES,
NULL, &type, (CONST LPBYTE)&uv, &cb))
{
}
}
이외에도 레지스트리를 이요해서 적절하게 정보를 변경해서
원하는 조이스틱을 사용해서 정보등을 변경 사용할수 있습
니다.
이외에도 다이렉트 플레이도 있는데, 요즘 급부상 하고 있는
머그 게임등에 이용할 수 있는 방법등이 다이렉트 플레이에서
지원합니다.
TCP/IP, IPX등의 네트워크 상에서 별도의 지식이나 어려움
없이 통신 관련 프로그램을 만들수 있습니다.
이것에 대해서는 다음 기회에 거론해보도록 하죠~
사실 조이스틱에 관해서는 그리 많이 설명할 것이 없습니다.
단순히 앞에서 본 내용이 전부 입니다.
원서(온라인 헬프)에서 보면 무척 많은 내용의 글이 적혀
있는데 것을 정리하면 이정도 밖에는 내용이 없군요~
이것으로 제 8장 다이렉트 인풋(조이스틱 처리)에 대해 배워
보았습니다.
--------------------------------------------------------
성남에서 조용한 주말을 보내면서 글을 적어 보았습니다.
- 이준곤 (LeeChen) -
#1402 서성칠 (ssc7 )
[강좌] LeeChen의 윈도우용 슈팅 만들기 #1 11/16 16:03 208 line
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
안녕하세요~ 이준곤(LeeChen)입니다.
////////////////////////////////////////////////////////////
그동안 저에게 아낌없는 성원보내주신 많은 하이텔, 천리안,
나우컴 게임 제작하는 분들께 진심으로 감사드리며, 계속해서 이
어지는 강좌의 독촉에 밀려 이렇게 내놓게 되었습니다. (^^;)
사실 2D게임 강좌를 3회분을 작성을 해놓았는데 윈도우95라는 운
영체제의 버그로 인해 날라 가버려서 부득이 하게 강좌가 늦어
졌습니다.
그럼 2D 게임을 제작해 보도록 하겠습니다.
다음 글에 관한 모든 저작권은 LeeChen에게 있으므로 본인 허락
없이 상업적인 목적에 사용되거나 다른 게시란에 기재될수 없습
니다.
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
*** 목 차 ***
* 1. 개괄적으로 알아 보는 2D 게임
1. 개괄적으로 알아 보는 2D 게임
1-1. 기획과 시나리오 제작을 해야 한다.
게임이라는 것이 기획을 하고 이번에 어떤 취지로 제작을 할것
인지 그리고 어떤식의 장르를 설정할지를 명시해야 한다.
게임 제작시 보통 3가지가 일치 되었을때 우수한 게임또는 뜨는
게임이 된다고 하는데, 하나는 유저들의 바라는 게임의 스타일
을 얼만큼 만족하는가? 두번째는 전체적인 게임의 흐름이 정확
해야 한다. 어설픈 게임 만큼 실망감을 주는 게임은 없을 것이
다. 세번째 기획력이다. 아무리 좋은 시나리오와 제작자들이
있다고 해도 조리있는 기획을 하지 않으면 안된다.
현재의 게임 제작사들의 문제중에 하나가 기획력이 떨어 진다
는 점이 무척이나 아쉽다. 경제적인 것이 뒷바침 되기 어려운
국내 게임 시장에서 장기간의 투자나 제작은 결국 별볼일 없
는 게임이 나오게 된다. 이런 문제점이 많은 유저에게 외국게
임을 선호하게 만드는 것이라고 할수 있겠다.
그러므로 앞으로 게임을 제작하는 프로그래머나 기획자들은
이것을 잘 알고서 제작사나 게임 제작에 참여 하는 것이 좋
을 듯 싶다.
1-2. 시장성 조사
사실 시장성 조사도 중요한 몫을 차지 한다. 왜냐 하면 제작
해놓고 팔리지 않는 게임은 쓸모가 없지 않는가?
그렇게 보면 현재 국내 시장에서 70~80%가 롤플레잉이나 전략
시뮬레이션이 아니가 한다. 그리고 10~20%가 액션류이고...
그럼 필자는 어떤 것을 제작할까요? (.... ~~!)
1-3. 어떤 2D게임을 제작할 것인가?
제작하는 입장에서 설명을 하려는데 무척이나 힘들군요?
사실 이렇쿵저렇쿵 이야기 해도 현실은 현실이니....
게제동에 많은 공개 게임이 슈팅이라죠? (자료실 뒤져 보자~)
쨘...(자료실 뒤져 보고 왔음~)
자료실에 보니 상용게임이 아닌이상 공개용은 거의 슈팅류가
피티기는 전쟁을 하고 있더군요~
요즘 하이텔 게제동이 공개 게임 대회가 있죠~ 이글을 읽고
한번 "나도 도전해 보자!" 하십시요~ 도스용이 아닌 윈도우
즈 용으로....
그~~래서...500원입니다가 아닌 슈팅을 제작해 보죠~ (^^;)
슈팅을 어떻게 제작할까? (극쩍~ 극쩍~)
1-4. 프로그램적인 개괄적인 설명
당연 이부분이 설명이 안되면 제가 할 필요가 없겠죠~
윈도우즈용 게임을 제작하는 위해서는 다음과 같은 조것이
필요 합니다.
1) 비쥬얼 씨 버전 5.0 사용
(그러나 안정성은 버전 4.2가 좋아서 4.2를 권장함)
2) 메모리는 당연 최소 사양인 32메가이상은 되어야 겠죠~
3) 포토샵 버전 4.X (그래픽 수정 작업시 필요)
( 만약 없다면 디럭스 페인터라도 필요함 )
4) 다이렉트엑스 버전 5.0 개발자용
5) 기타 등등
자~ 그럼 이제 무얼 더 알아 보아야 할까요?
없으면 말구.....
간단한 횡 스크롤 되면서 싸우는 단순하면서 단기간에 예
제로 적용하기에 적당한 스케일로 제작한다.
1-5. 각종 자료 구조 정리
슈팅에서 사용되는 자료 구조를 알아 보죠. 모든 슈팅이
이렇게 제작된다는 것은 아닙니다. 다만 이곳에서 제작
하는 게임에 한하여 자료구조를 정리 하는 것입니다.
1) 타일의 구조
[BYTE] 총갯수 // 255를 넘지 않을 듯하여
[BYTE] x 크기 // 크기 역시 그리 크지 않음
[BYTE] y 크기
[BYTE] 실제 데이타들 // 데이타 덩어리 ??
2) 맵의 구조
[2 byte] x 크기 // 사이즈가 얼만할지 모름
[2 byte] y 크기
[ BYTE ] 실제 데이타들
3) 스프라이트의 구조
타일 구조와 동일
자료 구조는 그리 복잡하지가 않죠? ^^;
일단 위의 3개의 자료만 존재 한다면 화면에 출력하는
것은 어렵지 않은 문제겠죠?
1-6. 사용되는 함수의 표준
객체 지향을 사용한 게임이기에 클래스라고 명시하는
것이 더욱 나을 지도 모르겠군요~
일단 타일을 관리는 더블 링크드 리스트로 이루어져
있습니다. MFC에 보면 CObject를 사용하면 쉽게 이것
을 구현 할수 있습니다. 하지만 이곳에서는 초보자분
을 위한 강좌이므로 C++의 기본적인 오퍼랜드를 이용
하여 더블 링크 구조를 작성하겠습니다.
class TileClass :
{
public:
void Load(char *fname);
void Save(char *fname);
void Put() { Put(m_x, m_y); }
void Put(int x, int y);
void Set(int x, int y) { m_x=x; m_y=y; }
TileClass &operator + (TileClass &t);
TileClass *prev;
TileClass *next;
BYTE *data;
int m_x;
int m_y;
};
데강 자료구조를 바탕으로 해서 클래스가 정의가 되
었나 싶군요? 이정도면 쓸만 한가? 하여가 위의 내용
을 콩볶아 먹듯이 만든 것이라....
그럼 이번에는 맵에 관련된 클래스를 정의 해 보죠~
class MapClass :
{
public:
void Load(char *fname);
void Save(char *fname);
void Put() { Put(m_xPos, m_yPos); }
void Put(int x, int y);
BYTE Get() { Put(m_xPos, m_yPos); }
BYTE Get(int x, int y);
void Set(int x, int y) { m_xPos=x; m_yPos=y; }
BYTE *data;
int m_xLen;
int m_yLen;
int m_xPos;
int m_yPos;
};
자..스프라이트는 어떤 구조일까? 타일과 같아요~
보시면 아시겠지만 구조가 다들 비슷 비슷합니다.
나중에라도 소스를 보면 이해가 쉬워야죠~ 그래서
소스는 될수 있으면 어렵지 않게 제작해야 겠죠~
자...오늘은 이만큼입니다.
더길게 쓰고 싶고 더욱 알찬 내용으로 여러분 앞에 내놓
고 싶은데....이렇게 실력이 없다보니...^^;
오늘은 성남이 아니고 시골의 산속에 있는 작은 별장에서
글을 씁니다. 이곳에서도 낙엽이 많이 떨어졌군요~
겨울이 성큼 다가 오는 느낌이군요~
감기 조심하세요~
- LeeChen -
#1516 서성칠 (ssc7 )
[강좌] LeeChen:MFC에서 게임을 만들자 01 03/20 01:31 308 line
=================================================================
안녕하세요~ 이준곤(LeeChen)입니다.
=================================================================
강의 주제 : DirectX를 MFC에서 사용하자~
제 1 장 MFC로 구현하는 풀스크린 처리 방법
-> 1. DirectX의 평면 구조와 기본 클래스 구성
많은 분께서 "언제나 강좌를 하나요?"라고 많은 질문을 해오시더군요~
사실 2D 강좌를 해놓고 본의아니게 자료가 날라 가는 바람에~
( 제 하드가 간혹 멈추는 짖을 하거든요~ 그러면 시스템이 다운이....)
지난번에는 주로 API를 위주로 다이렉트 엑스를 설명을 한것 같습니다.
이번에는 많은 량의 강좌는 안될것 같은데 간단하게 집고 넘어 가려고
글을 쓰기로 하였습니다. 기다려 주시는 분들도 계시고 해서...
제가 다이렉트 엑스라는 것을 처음 접한것은 2버전때 였습니다. 벌써
2년이상이 지났군요~ 그후로 버전이 3.0....5.2까지 나와 있는데 이미
게임 관련되 루틴은 3버전에서 확고히 자리가 잡힌 것같습니다.
5.0은 3차원 기능을 향상한점에서 조금 나아 졌고~ 5.2는 DVD기능을
첨가했다고 하는 군요~
그리고 앞으로 나올 6.0에서는 어떻게 나올지는 모르지만 3차원 기능이
Opengl과 혼합형태로 나올것 같다는 전망이 많더군요~
제가 본격적으로 이야기 할건 이런 겉치장의 기능향상이 아닌 실속있는
기능 향상을 보자면, 새로운 인터페이스 IDDVideoPortContainer,
DirectDrawColorControl,IDirectDrawVideoPort, 그리고
IDirectDrawSurface3포함 되어 있고, IDirectDrawSurface2가 보충 공유
되어 있고. 주요한 개선된 점은 넓은 표면을 생성할 수 있다는 것입니다.
사실 이부분은 제가 인터넷을 통해 얻은 자료를번역해서 올리려다
이렇게 다시 편집해서 올립니다. 각각으 기능은 이미 5.0 레퍼런스의
서두에 나오는 것인데 자세한 것은 레퍼런스를 참조해 주세요~
(해석이 안되시는 분은 저에게 질문을 주셔도 됩니다. )
지금 인터넷을 통해 게임 컴퓨터 동향을 살펴 보면 3차원을 가지고
치열한 전쟁을 치루고 있더군요~ 특히 오픈지엘이냐~ 다이렉트엑스냐~
의 두진영이 치열하고 간혹 독자적인 그러나 그리 힘을 발휘할수 없는
독자노선을 추구하는 팀이나 회사도 있더군요~
어쨌거나 3차원에서 많이 사용하고 있는 것은 오픈지엘과 다이렉트 엑스
인데 오픈지엘은 이미 리눅스나 유닉스, 그리고 솔라리스, 오에스투,
윈도우즈 95등등 많은 운영체제에서 사용되어 왔고 기능또한 편리하게
되어 있어 함수 레퍼런스만을 가지고 3차원 감각이 있는(개념이 잡혀
있는) 독자라면 누구나 구현할수 있게 되어 있습니다.
그런 반면 다이렉트 엑스는 빠르다는 것을 추구하지만 워낙 많은
변수와 인자와의 전쟁을 한바탕치루고 난후에야 가능하니 조금 번거
롭더군요~
하지만 다이렉트 3차원을 각자 본인의 구미에 맞게 잘 구성해놓고
나름데로 인터페이스를 구성만 된다면 오픈지엘보다 편리하게 쓸수도
있겠죠~ (이것은 독자의 몫!)
일단 많은 독분들이 MFC를 두려워하고 있는 것 같아 다이렉트엑스를
어떻게 하면 MFC와 쉽게 접목해서 사용할 수 있는지를 2차원 프로그
램과 3차원 프로그램을 각각 제작하면서 배워 보도록 하죠~
(약간 글이 어색할 수도 있는데 자료중 원어를 그데로 번역해서 넣은
부분도 있다보니 조금 이상할 수도 있는데 제가 나름데로 정리하려고
했는데 아직 자료들이 정리가 안되어 이렇게 서둘러 작성해 올립니다.
)
PS. -------------------------------------------------------------
이글의 모든 저작권은 이준곤(LeeChen)에게 있으면 본인의 허락없이
불법적으로 도용하거나 다른 곳에 기재할 수 없습니다. 또한 처음 MFC
를 다루는 분이나 DirectX를 기본적으로 하시는 분의 눈높이에 맞추어
작성되어 있음을 밝힘!(실력이 좋으신 분은 안읽어도 되요~ ^^;).
-----------------------------------------------------------------
1. 다이렉트 엑스의 사용
이미 앞서 저의 글을 읽으신 분이나 공부를 하신분은 다이렉트 엑스가
어떤거구나 하는 것을 아실겁니다. 보다 빠른 그래픽 처리를 위한
드라이버인데, 이것을 사용하는 방법은 풀화면을 다 이용하는 방법과
윈도우즈 모드로 작성하는 방법 두가지가 있다는 것을 아실겁니다.
모른다구요~ 그렇다면 이렇게 두가지로 사용할수 있습니다.
저는 다이렉트 엑스를 사용할때 IDirectDrawSurface2것을 자주 사용
하는데 이유는 기존의 다이렉트 엑스를 사용하는 프로그램이 있다면
그것과 충돌을 일으키지 않으려고 이것을 사용합니다. 보통
IDirectDrawSurface를 사용합니다. 특히 온에어라는 TV수신카드의
프로그램은 IDirectDrawSurface를 이용해 화면에 TV내용을 찍는데
이것과의 충돌을 읽으키지 않으려면 다른 Surface를 사용해서 출력
하는 것이 낳겠죠~
일단 다이렉트 엑스를 MFC에서 사용하기 위해 그에 적합한 코딩을
해놓아야 겠죠~
class CDirectDraw
{
public:
// two phase construction
CDirectDraw ();
void Create (HWND hWnd,
DWORD dwDisplayWidth, DWORD dwDisplayHeight,
DWORD dwBitPlanes, DWORD RefreshRate=0);
................
................
~CDirectDraw ();
public:
// surface를 제어
CPrimarySurface& FrontSurface ();
CBackBuffer& BackBuffer (int iNumBackBuffer=0);
.................
.................
// Load a palette from a bitmap:
void LoadPalette (LPCSTR szBitmap);
// 파레트 관련 함수
void GetEntries (DWORD dwBase, DWORD dwNumEntries, LPPALETTEENTRY lpEntries);
void SetEntries (DWORD dwStartingEntry, DWORD dwCount,
LPPALETTEENTRY lpEntries);
private:
// Guard against copies
CDirectDraw (const CDirectDraw& src);
CDirectDraw& operator = (const CDirectDraw& src);
};
다이렉트 엑스를 생성시 IDirectDraw2를 최초의 면에 이용했고 그다음
뒷면도 이것을 이용해 생성했다. 그리고 단일 파레트만을 사용하게
해놓았다. 이것은 어디까지나 예제를 위해 제작된 것이므로...
다음에 제작된 CreateDDInterface는 생성하면서 발생되는 에러를 적절
하게 디버그 모드상에서 처리되겠금 되어 있다. 그리고
void CDirectDraw::CreateDDInterface ()
{
LPDIRECTDRAW lpDD_v1;
HRESULT ddrval = DirectDrawCreate (NULL, &lpDD_v1, NULL);
switch (ddrval)
{
case DD_OK:
// 성공하면
break;
#ifdef _DEBUG
case DDERR_INVALIDPARAMS:
TRACE ("Invalid parameters.\n");
ASSERT (FALSE);
break;
case DDERR_INVALIDDIRECTDRAWGUID:
TRACE ("Invalid GUID.\n");
ASSERT (FALSE);
break;
case DDERR_DIRECTDRAWALREADYCREATED:
TRACE ("DirectDraw object was alreadyaleady created.\n");
ASSERT (FALSE);
break;
case DDERR_GENERIC:
TRACE ("Generic error creating the interface.\n");
throw ddrval;
break;
case DDERR_NODIRECTDRAWHW:
TRACE ("DirectDraw hardware is not available.\n");
throw ddrval;
break;
case DDERR_OUTOFMEMORY:
TRACE ("Out of memory.\n");
throw ddrval;
break;
#endif
default:
TRACE ("Undocumented error.\n");
throw ddrval;
}
// 바로 이부분이 제2의 평면을 사용하게 하는 부분이다.
ddrval = lpDD_v1->QueryInterface ( IID_IDirectDraw2, (LPVOID *)&m_lpDD);
......
......
}
앞의 내용을 다시 간단하게 정리하면...
void CDirectDraw::CreateDDInterface ()
{
LPDIRECTDRAW lpDD_v1;
HRESULT ddrval = DirectDrawCreate (NULL, &lpDD_v1, NULL);
switch (ddrval)
{
case DD_OK:
// 성공하면
break;
default:
TRACE ("Undocumented error.\n");
throw ddrval;
}
ddrval = lpDD_v1->QueryInterface ( IID_IDirectDraw2, (LPVOID *)&m_lpDD);
......
......
}
자~ 여기서 앞으로 사용된 평면에 관해 알아 보도록 하자~
2. 사용되는 평면들
필자는 평면들을 구성하는데 있어 각각의 클래스로 정의해 두었다.
아마도 많은 분은 변수하나로 처리하면 될걸? 왜? 클래스로 하지?
하실테데.. 각각의 기능을 구분을 하고 그에 따라 독자적인 처리로
보다 효과를 주기 위해서 입니다.
1) CPrimarySurface class
아주 간단하게 구성이 되어 있는데, 뒤에 생성된 평면과 화면
전환을 위해 생성. 오직 보여주기 위한 평면 클래스다.
2) CBackBuffer class
실제 독자가 직접 그림을 그리고 변형을 가하는 평면이다.
3) CBitmapSurface class
게임에 사용되는 그림을 담아 두는 주로 비트맵을 담는데 사용
되는 평면 클래스이다.
다음 소스는 어디서 많이 본듯한 예제인데 어디서 보던 소스인데...
어딜까요? SDK의 Sample에 보시면 도너츠를 움직이는 예제가 있을
겁니다. 한번 살펴 보세요~
ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
if( ddrval != DD_OK )
{
return initFail(hwnd);
}
// Get exclusive mode
ddrval = lpDD->SetCooperativeLevel( hwnd, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN );
if( ddrval != DD_OK )
{
return initFail(hwnd);
}
// Set the video mode to 640 by 480 by 8640x480x8
ddrval = lpDD->SetDisplayMode( 640, 480, 8);
if(ddrval != DD_OK)
{
return initFail(hwnd);
}
// Create the primary surface with 1 back buffer
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
DDSCAPS_FLIP |
DDSCAPS_COMPLEX;
ddsd.dwBackBufferCount = 1;
ddrval = lpDD->CreateSurface( &ddsd, &lpDDSPrimary, NULL );
if( ddrval != DD_OK )
{
return initFail(hwnd);
}
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddrval = lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack);
if( ddrval != DD_OK )
{
return initFail(hwnd);
}
지난번 글을 소화해낸 분이라면 이정도는 아무것도 아니게 이해가
^^;
아주 간단한 다이렉트 엑스 생성 부분입니다. 위의 코드와 다른점이
몇군데 있죠~ 지난번 강좌까지는 이런 형태의 코드로 이야기 했고
앞으로는 저위의 코드로 강좌를 합니다.
위의 클래스의 함수들을 어떻게 쓸까? 하는 의문이 생길텐데
다음과 같이 사용됩니다. 파레트 셋팅과 다이렉트 엑스 생성~
//
// 다이렉트 엑스를 생성하는 부분
//
m_DirectDraw.Create (hwnd, 640, 480, 8);
// create and set the palette
m_Palette.Create ();
m_DirectDraw.SetPalette (m_Palette);
일단 여기까지 하고요~ 다음에 하기 전에 알려 드릴것은~
MFC에는 SDI 와 MDI라고 하는 것이 존재하는데 저는 이강좌에서
SDI를 위주로 하려고 합니다. 보다 간편하기 때문이죠~
MFC를 이용해 전체화면을 사용하는 방법을 모색해보고 그다름
창모드에서 작업하는 방법을 알려 드리죠~
API를 쓰다가 MFC를 사용해보면 이렇게 편리한 것을 몰랐나 할
겁니다. 두번다시는 API를 안쓰지 않을까 하네요~
제2의 강좌에서는 본격적인 MFC를 이용하도록 하죠~
흐르는 물은 멈추게 할수 있지만
시간의 흐름은 누구나
멈출수도 돌릴수도 없네~
#1517 서성칠 (ssc7 )
[강좌] LeeChen:MFC에서 게임을 만들자 02 03/20 01:32 332 line
=================================================================
안녕하세요~ 이준곤(LeeChen)입니다.
=================================================================
강의 주제 : DirectX를 MFC에서 사용하자~
제 1장 MFC로 구현하는 풀스크린 처리 방법
1. DirectX의 평면 구조와 기본 클래스 구성
-> 2. 실제 MFC의 메세지 맵 구성
오늘은 MFC의 메세지맵을 구성하는 방법과 DirectX 와의 접목을 이야기
해보도록 합시다. 두번째 시간인 만큼 첫번째때보다 시간적 여유를 가
지고 강의를써 나가도록 하겠습니다.
PS. -------------------------------------------------------------
이글의 모든 저작권은 이준곤(LeeChen)에게 있으면 본인의 허락없이
불법적으로 도용하거나 다른 곳에 기재할 수 없습니다. 또한 처음 MFC
를 다루는 분이나 DirectX를 기본적으로 하시는 분의 눈높이에 맞추어
작성되어 있음을 밝힘!(실력이 좋으신 분은 안읽어도 되요~ ^^;).
-----------------------------------------------------------------
3. 메세지 맵의 구성
보통 MFC를 어떻게 배워야 할지? 그리고 매우고 난후 어떻게 써야 할
지를 망설이는 분이 많습니다. 그런데 잘 활용하면 무척이나 쉽고 간
단한게 처리를 할수 있는 장점이 많습니다.
Microsoft Developer Stidio[VC 에디터]에서 New를 선택하면 탭메뉴
중 Project를 선택하면 에구~ 무슨 위자드(Wizard)가 많은지? 얼레?
무얼 선택해야~ 하나? (음...단번에 또는 통밥으로 맞추시는 분이
있군요~) MFC AppWizard(exe)라는 메뉴가 있는데 이것을 선택해서
다음에 물어보는 것을 상세히 읽어보신후 나중에 완성이 된 메세지가
무조건적으로 다음과 같은 메세지가 나옵니다.
+- Application : CDemoApp class
|
+- Frame : CMainFrame class
|
+- Document : CDemoDoc class
|
+- View : CDemoView class
위의 4개의 클래스가 생성이 됩니다. 바로 클래스가 메세지를 뜻하는
데 처음에 관련 정보 생성, 각각의 윈도우의 프래임을 관리, 문서의
정보 관리, 마지막으로 보여 주면 되겠죠~
일단 이렇게 알고 계세요~ 더욱 자세한 내용은 MFC관련 책자를 보
시면 보다 상세히 각각의 메세지에 대해 알아 볼수 있을 겁니다.
(요건 무슨 의미이냐면 적어도 MFC관련책자는 한권은 있어야
한다는 이야기죠~ ^^;)
자~ 그럼 저기 4개의 메세지가 필요할까요? ..............
필요합니다. 그런데 여기서 두가지를 생각해 두어야 합니다. 무얼까?
바로 어떤 모드에서 MFC를 사용할 것인가 하는 문제가 있는데 바로
이문제를 전제로 하고서 메세지 맵을 관리 해야 합니다.
윈도우즈 모드에서 다이렉트 엑스를 사용한다면 윈도우즈 규약에 맞
추어서 제작을 해야 합니다. 그건 문서관리와 보여지는 처리를 해야
하는 번거로움이 따릅니다. 하지만 객체 처리는 독자적으로하고
보이는 화면을 보여주기만 하면 어떻까요? 보통 게임에서는 이런
방법을 사용하죠~
일단 가장 간단해 보이는 전체화면을 사용하는 프로그램을 작성해
보도록 하죠~
풀화면을 사용하면 문서관리가 필요할까요? 화면전체를 가득 독자가
제작한 그림들로 체우는 상태에서 별도의 보이라는 메세지를 윈도우
즈에게 보낼 필요가 있을까요? 그러니가~ 여기서 메세지는 MFC의
메세지를 말합니다.
일단 필요한 것을 보자면 초기화를 위한 메세지가 필요합니다.
게임을 처음 생성하면서 앞으로 사용될 모드에 대해 윈도우즈에게
'나 이렇게 쓸꺼여~'라고 알려 주는 메세지와~ 도스에서 제작하던
방식인 Main()함수격인 프래임 처리 메세지만 있으면 끝이겠죠~
쓸때 없는 화일은 지우자~ 무얼 지워야 할까? 바로 도큐먼트함수가
있는 화일과 비~유 클래스가 있는 화일을 지우면 됩니다.~ 아주 간
단하죠~ 그러면 무엇이 남죠?
+- Application : CDemoApp class
|
+- Frame : CMainFrame class
이것만이 남게 되는데 이것을 적절하게 사용하면 됩니다.
메세지중에 Idle이라는 메세지가 있는데 이것은 윈도우즈 프로그램
을 공부하신 분이라면아시겠지만 메세지가 없는 상태를 포착해서
독자가 그시간을 사용하게 해주는 메세지입니다.
이메세지는 MFC에서 함수로 제공을 해줍니다. 보통 API에서는 함수
로 제공되기 보다는
while(무조건 돌아라~) {
while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) !=0 ) {
if( GetMessage( &msg, NULL, 0, 0) == 0 ) 프로그램 끝내자~;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (활성화 되었냐?)
그럼 내가 처리하고 픈 함수 실행할래~
}
하하~ 이렇게 API에서는 WinMain()이라는 부분에 메세지를 별도로
체크해서 사용해야 했습니다. 그런데 MFC에서는 달랑~ OnIdle()이
라는 함수가 제공이 된다니....(비통하구나~ 이것을 빨리 알았으면
... 하시는 분도 있겠죠~)
4. Application Message
자~ 그러면 메뉴중에서 클래스 위자드를 실행해서 뛰우자~ 그것을
뛰우면 ClassName을 뒤적뒤적하면 '나클래스야App'라는 메세지가 있
는데 이것에 고정하고 메지창에서 OnIdle라는 것을 클릭하면 와우~
멤버 함수란을 보면 이함수가 들어 와있을 겁니다.
그러면 에디트 코드라는 버튼바를 눌러 보면
BOOL 나클래스야App::OnIdle(LONG lCount)
{
CWinApp::OnIdle (lCount);
return 참일깨롱~;
}
이렇게 나타난다는 전설아닌 전설이 있더군요~
그럼 이부분을 어떻게 이용할까요? 독자분이 돌리고자하는 프로그
램을 이함수에 넣으면 그냥~ O~K~
잠깐 예를 들자면
BOOL 나클래스야App::화면을 업데이트할래()
{
if (!((CMainFrame*)m_pMainWnd)->m_bActive)
return FALSE;
DWORD thisTickCount;
RECT rcRect;
DWORD delay[4] = {50, 78, 13, 93};
int i;
PALETTEENTRY pe[256];
HRESULT ddrval;
// Decide which frame will be blitted next
thisTickCount = GetTickCount();
...................
...................
return 참일깨롱~;
}
void 나클래스야App::모두 복구할래()
{
// m_DD.FrontSurface().Restore ();
// m_Surface.Restore();
}
그렇다면 사용을 어떻게 해야죠? 음..간단하야~ 업데이트함수를
이용하면 됩니다.
BOOL 나클래스야App::OnIdle(LONG lCount)
{
CWinApp::OnIdle (lCount);
return 화면을 업데이트할래();
}
바뀌었죠~ 이렇게 되면 일단 화면이 갱신이 되겠금 메세지를
구성했습니다. 우와~ 아주 쉽죠~
일단 이부분의 메세지를 이렇게 제작을 해놓고~
5. MainFrame Message
이메세지는 당연 프로그램의 핵심부분이라고 해도 과언이 아닌
부분이라고 짐작하시는 분이 계시겠죠~ 당근입니다!
다시 보자면~ "MFC의 모든 것은 클래스 위자드로 클래스 위자
드는 MFC의 메세지로~" 이것이 진리요~ 참이로다~ ( 우헤헤~ )
웬헛소리가...이것이 바로 MFC를 사용하다 보면 나타나는 증세?
일단 클래스 위자드를 실행하자~ 당연 메뉴에서 클래스 위자드
를 찾아서 클릭을 하면 되겠죠~ 거기에 보면 클래스 이름에
보면 'CMainFrame'이라는 것이 있죠~ 그것을 고르면 멤버함수
란을 보면 달랑~ PreCreateWindow() 함수만이 존재하는 것을
알수 있을 겁니다.
이함수를 일단 에디팅합니다. 에디트 코드바를 눌러서 화면을
갱신합시다.
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CFrameWnd::PreCreateWindow(cs);
}
요렇게 구성이 되어 있습니다. 이함수의 특징은 윈도우즈를
생성할때 그러니까~ 독자께서 제작하는 프로그램의 윈도우즈
스타일을 정의해서 생성하게 하는 부분입니다.
그러면 CREATESTRUCT 구조체에다가 커서를 갔다데고~ F1키를
눌러 보세요~ 어떤 쓸때 없는 말들이?? (잉? 왜 내겐 암호처럼
보이는 글자들이 나타나는 걸까? 하하~)
거기 구조체를 살펴보면 화면의 크기를 정의 하는 변수가
있습니다.
그변수에 값을 넣어 윈도우즈 크기를 정의 합시다.
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.x = cs.y = 0;
cs.cx = GetSystemMetrics (SM_CXSCREEN);
cs.cy = GetSystemMetrics (SM_CYSCREEN);
return CFrameWnd::PreCreateWindow(cs);
}
이렇게 바꿉시다~ 여기서 시작 좌표는 0이라는 값으로 초기화
하여 두었고~ 윈도우즈 크기는 현재 시스템의 최대값을 받아서
셋팅하겠금 되어 하여 두었습니다.
와~우 MFC도 별개 아니네?
자~ 그럼 이것가지고 다이렉트 엑스가? 뜰까나? 앞으로 갈길이
남아 있고....잠시후....(무려 5시간 후 우랄랄~ 그사이에 어떤
일이?)
다시 마음을 가다듬고...이번에는 게임을 진행하는데 있어 키
보드는 놀고 있을까요? 전혀 아니죠~ 간단하게 게임을 빠져 나
오려고 할때 ESC 키를 누르면 그에 해당하는 반응을 해야 겠지
요~ 그리고 기타 독자분들이 어떤 키를 넣어 보겠다고 한다면
그에 해당하는 메세지도 첨가해야 겠지요~
어떻게 첨가해야 하죠? 에고고...어쩌나...그런데 API에서는
어떻게 처리를 했죠~ 그때를 아십니까?
case WM_KEYDOWN :
if( wParam == VK_UP )
올리래();
if( wParam == VK_DOWN )
내릴래();
if( wParam == VK_LEFT )
왼쪽으로 갈래();
if( wParam == VK_RIGHT )
오른쪽으로 갈래();
.............
.............
break;
이런식으로 처리를 했었습니다. 음 그리고 별도로 함수를 만들
기도 하지만 그래도 어째건 이런식으로 처리를 했습니다.
이미 윈도우즈 프로그램을 했던분이라면 낮익는 소스 부분이라
꺼리김 없이 아하~ 그렇군 하시겠죠~
그렇다면 MFC에서는 이런 부분을 어떻게 처리를 할꼬나?
클래스 위자드에서 보면 WM_KEYDOWN이라는 부분이 있습니다.
이부분을 두번 클릭하면 멤버함수에 OnKeyDown이라는 함수가
생성이 됩니다. 그럼 역시 에디트 버튼을 눌러보면 다음과 같
은 소스가 나타날겁니다.
void CMainFrame::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// 버츄얼 키중에 ESC와 F12를 눌렀을때 프로그램을 끝냄
if ((nChar == VK_ESCAPE) || (nChar == VK_F12))
PostMessage(WM_CLOSE, 0, 0);
CFrameWnd::OnKeyDown(nChar, nRepCnt, nFlags);
}
와우~ 간단해 보이죠~ 그럼요~ 간단하게 처리되겠금 되어 있는
것이 MFC입니다.
그다음 화면을 갱신하는 메세지가 있어야 적절한 윈도우즈 내부
시간에 맞추어 화면이 갱신이 되겠지요~ 이부분은 다음 어떻게
처리를 해야 좋을까나?
앞서 배운 방법처럼 메세지 부분에서 WM_PAINT라는 부분을 클릭
하여 함수를 생성하면 됩니다. 윈도우즈 창을 이용해서 사용되는
프로그램이 아니므로 별도의 갱신처리 루틴은 필요 없습니다.
단순이 이메세지를 넣어 줌으로 화면 갱신이 이루어 지게 됩니
다.
그럼 다음과 같은 코드가 생성이 되어 있을 겁니다.
void CMainFrame::OnPaint()
{
CPaintDC dc(this); // device context for painting
// TODO: Add your message handler code here
// We need do nothing.
// Do not call CFrameWnd::OnPaint() for painting messages
}
여기서 this가 나타내듯 자신의 DC를 갱신하게 됩니다.
[#참고] 여기서 this 연산자는 C++에서 사용되는 연산자로 자신
을 나타내는 연산자 또는 프로그램의 예약어라고 할수 있습니다.
즉, 메모리의 포인터 연산자와는 별개로 처리되지만 실제 뜯어
보면 비슷한 기능을 하면서 사용상 의미는 다르다. 메모리가
지시하는 것의 명확성을 두기위해 this연산자를 사용한다.
(이구 이것이 맞다고 주장할수 없지만 이렇게 이해하면 한결
도움이 되겠지요~ ^^;)
기타 활성화 되어 있는지의 여부를 판단하는 메세지도 있고 첨가
가능한 메세지는 클래스 위자등에 있습니다.
첨가할 수 있는 기능, 하지만 꼭 필요한 것만을 넣어야 합니다.
자~ 이정도 되면 어느정도 MFC 의 풀스크린을 이용한 게임을
제작할수 있습니다. 그다음 나머지 캐릭터의 동작이나 인공지능
처리, 찍기등등의 게임의 기능은 별도의 함수로 제작하고 어디?
바로 Application 클래스의 Idle함수에 첨가하면 됩니다.
여기까지 1장의 MFC를 이용한 풀스크린 활용편이였습니다.
다음시간에 제 2장 윈도우즈 모드를 이용하는 방법을 알아 보도록
하지요~ 조금 복잡한데 (메세지가 많거든요~) 하나하나 살펴
보면서 제작을 해보도록 하지요~
-광고-
여기까지 제1장에 관련된 내용의 소스를 하이텔 게제동 자료실에
올려 놓았습니다. 기본적인 다이렉트 관련 내용보다 MFC에 중점
처리 루틴을 살펴 보시기 바랍니다.
#1518 서성칠 (ssc7 )
[강좌] LeeChen:MFC에서 게임을 만들자 03 03/20 02:45 192 line
=================================================================
안녕하세요~ 이준곤(LeeChen)입니다.
=================================================================
강의 주제 : DirectX를 MFC에서 사용하자~
제 1장 MFC로 구현하는 풀스크린 처리 방법
1. DirectX의 평면 구조와 기본 클래스 구성
2. 실제 MFC의 메세지 맵 구성
제 2장 MFC로 구현하는 윈도우 모드 처리 방법
-> 1. MFC의 특징과 메세지 구조
벌써 3번째 강의를 준비해야 하는 시간이 되었군요. 매번 강좌를준비
하면서 무척이나 긴장되고 걱정이 됩니다. 왜냐구요? 어떻게 하면 보
다 쉽게 독자분들께 이해를 시켜드릴까 싶은 마음에... ^^;
이번 시간부터는 다이렉트 엑스를 이용해 맵에디터나 스프라이트 동작
툴을 제작할수 있는 기반을 다지기 위하여 MFC를 이용한 윈도우즈 모
드용으로 공부하도록 합시다.
PS. -------------------------------------------------------------
이글의 모든 저작권은 이준곤(LeeChen)에게 있으면 본인의 허락없이
불법적으로 도용하거나 다른 곳에 기재할 수 없습니다. 또한 처음 MFC
를 다루는 분이나 DirectX를 기본적으로 하시는 분의 눈높이에 맞추어
작성되어 있음을 밝힘!(실력이 좋으신 분은 안읽어도 되요~ ^^;).
-----------------------------------------------------------------
1. MFC로 제작된 프로그램의 특징
일반적으로 공통적인 표준을 가지고서 윈도우즈 프로그램을 제작하게
됩니다. 이것은 이미 API를 공부하면서 윈도우즈의 표준을 따르면서
발생되는 인터페이스의 디자인의 표준화가 생기어 사용하는 유저로
하여금 혼돈을 일으킴이 없이 체계성을 보여주기 위함이 아닐까 합니
다.
그런 면에서 MFC로 제작하는데에도 어떠한 공통된 통일성이 따릅니다.
툴바의 생성, 도움말 보기 기능, 메뉴기능 등등 도스시절에는 복잡하
게 팝업이니 풀다운이니 아이콘 생성 방법이니 하여 별도로 배우고
습득해서 처리하니 이리 저리 시간도 걸리고 사용하는 사람으로 하여
습득력도 필요로 하게 했습니다. 그러나 윈도우즈는 통일된 인터페이
스로 쉽게 제작하고 사용하는 것이 마음이 들죠~
자~ 필자가 왜 이런 말을 했냐면 바로 윈도우즈 모드로 제작하는 프
로그램에 있어 인터페이스 부분을 신경을 안쓸수 없다는 것이죠~
하지만 API에서는 어떻게 했나요? 일일이 해당 부분을 제작해주어야
했지요~ 그러나 MFC는 처음 프로젝트 생성시 조건에 맞는 코드생성이
이루어지므로 인해 간단한 인터페이스는 구성이 되어 있다는 것이죠~
지금이라도 쉽게 생성된 소스를 F7를 눌러 컴파일후 실행을 해보시면
쉽게 아실겁니다.
메세지의 쉬운 관리
이건 API를 사용하다 MFC를 사용하면 처음부터 느끼는 점인데 메세지
를 함수단위로 관리하고 특히 클래스 위자드로 인해 관리되므로 특별
히 신경쓰지 않아도 원하는 기능을 추가하면 됩니다.
이보다 MFC의 특징은 많은데 제가 다 늘어 놓을 수는 없고, 실제로
독자분들이 제작을 하면서 피부로 느끼는 것이 빠를겁니다.
2. 윈도우즈 모드에서의 메세지 구조
앞서 배운 풀스크린 모드에서는 Application과 Frame이라는 두개의
클래스를 이용했다. 그것은 별도의 화면 갱신이 필요없다 쓸때 없는
메세지로 인해 번거로움을 없애기 위해서이다.
특별히 툴바라던가 메뉴가 나오는 것도 안닌데 도규멘트 메세지니
뷰메세지가 필요없기 때문이다.
이방법말고도 아이알로그를 이용해 하는 방법이 있는데처음 소스를
생성할때 다이알로그로 생성하면 많은 량의 메세지가 없는데 이것
을 사용해서 게임을 제작하는 방법도 좋을 것이다.
그렇다면 이번제작하는 윈모드용 게임은 어떤식으로 메세지가 구성
되어 있나를 살펴보면
+- Application : CDemoApp class
|
+- Frame : CMainFrame class
|
+- Document : CDemoDoc class
|
+- View : CDemoView class
오잉? 기존의 메세지와 전혀 다를것이 없네? 음~ 이이상의 메세지는
독자분들이 필요한 다이알로그를 생성할때 필요 하지만 제가제시하는
MFC로 에니메이션이 되는 프로그램은 이정도 클래스면 충분합니다.
이번에 제작되는 윈모드용은 풀모드에 비해 View 부분이 강조가 되는
부분이다. 그러므로 이부분을 상세히 집고 넘어 가도록 하고 일단 각
각의 메세지에 대해 알아 보고 지나가자~
1) CAboutDlg 는 도움말을 처리하기 위한 부분이데 특별이 신경쓸건
없습니다. 다만 리소스 관리기에서 도움말이 나오는 박스를 이리
저리 모양을 내어 멋을 들여 놓으면 끝~
2) CDemoApp 에서 사용되는 주된 기능은 Idle Time발생하는 것을 이
용해 독자분들이 필요로 하는 기능을 사용하면 됩니다.
3) CMainFrame 에서는 지난번과는 다르게 중요성은 떨어진다. 하지만
없으면 안되는 클래스입니다. 그러면 어떤 기능을 첨가하느냐?
바로 툴바를 생성하고 메뉴을 생성하고, 그리고 가장 중요한 윈도
우의 기본 바탕이 되는 화면 박스의 디자인을 해야 겠죠~ 이건 지
난번 시간에 이야기 했으니 그것을 참조~
4) CDemoDoc 현재 에니메이션을 구현하므로 별도의 문서를 관리할 필
요는 없지요~ 그러니 이부분은 신경을 꺼도 됩니다. 허나 지우거
나 없애면 크나큰 오류가....(이걸 지울경우 감당할 문제는 허허~
어찌도리런지?)
5) CDemoView 드디어 가장 중요한 이클래스는 윈모드의 게임제작에
지대한 영향력을 발휘하는 클래스라고 해도 과언이 아니라 합니다
3. Application 메세지의 구성
이번에 제작하는 Application 메세지는 지난번과 별다른 것은 없다
하지만 지난번보다 수월하다 왜냐면 쉬는 시간을 체크하는 함수이외에
추가 함수를 이곳에 집중할 필요가 없다.
메세지중 OnIdle를 추가해서 다음과 같은 소스를 약간 수정을 해준다.
BOOL CMfcddex3App::OnIdle(LONG lCount)
{
CWinApp::OnIdle (lCount);
// Find the active view:
CDemo3View* pActiveView = (CMfcddex3View*)((CMainFrame*)
(m_pMainWnd))->GetActiveView ();
return pActiveView->updateFrame ();
}
여기서 CDemo3View 클래스는 앞서 설명했지만 윈모드에서 사용되는 모
든 처리는 View에 있으므로 그곳에 화면 갱신처리 함수가 있다 그러므
로 이곳 응용프로그램의 메세지중 쉬는 시간에 화면을 갱신 해주겠금
하면 일단 자동 플립핑이 일어나겠지요~
와우...쉽다 쉬워~ 쉬운건 누구나 할수 있는 것이죠~ MFC도 누구나 할
수 있는 것입니다.
[참고] 리소스로 제작된 다이알로그의 메세지
보통 독자분이 제작된 다이알로그를 화면에 뛰어야 하는데 어떻게 해
야 할까? API에서는 다이알로그를 뛰우기 위해 DialogBox()라는 함수
를 이용해서 생성하고 EndDialog()로 닫고 했을 겁니다.
하지만 MFC에서는 해당 리소스의 이름을 클릭하면 DoDataExchange라
는 함수가 있는데 다이알로그를 초기화와 생성을 해줍니다. 이렇게
하므로 쉽게 등록을 할수 있습니다.
이외에도 리소스의 기능을 추가하기위해 Command 함수가 생깁니다.
이런것은 직접 메세지 레퍼런스나 MFC의 읽기 괜찮은 책을 읽어 보시
면 자세히 나옵니다.
=================================================================
산이라 하면....
산은 어릴적 친구 였지.
가르침을 주는 아버지였지.
아늑함을 주는 어머니였지.
떠날때까지 나와 함께 했지.
항상 그자리에 변함없이 있었지.
나에게 언제든 찾아오라 하였지.
세상은 무척이나 힘겨웠지.
가끔은 반항과 좌절도 했지.
이길수 없는 세상을 원망도 했지.
살아가는 동안 잊고 살았지.
홀로 된다는 슬픔에 가끔 찾긴했지.
세월은 흐르는 유수라 했지.
망고에 산의 품에 안기었지.
산은 아무말 없이 나를 반겼지.
산의 품은 무척이나 따뜻했지.
어릴적 잊쳐진 정겨움이였지.
세월에 바랜 아품들이 녹아 내렸지.
더이상 떠나지 않겠다 했지.
그리고 나는 한없이 울었지.
한평생 그리워하던 산의 품에서
- LeeChen -
#1519 서성칠 (ssc7 )
[강좌] LeeChen:MFC에서 게임을 만들자 04 03/23 08:51 298 line
=================================================================
안녕하세요~ 이준곤(LeeChen)입니다.
=================================================================
강의 주제 : DirectX를 MFC에서 사용하자~
제 1장 MFC로 구현하는 풀스크린 처리 방법
1. DirectX의 평면 구조와 기본 클래스 구성
2. 실제 MFC의 메세지 맵 구성
제 2장 MFC로 구현하는 윈도우 모드 처리 방법
1. MFC의 특징과 메세지 구조
2. DirectX 사용 위치와 전체적인 프로그램
에구구....4번째 마지막 글을 써야 하는데 이걸 깜박잊고 다른 일을
하다보니...
인터넷에 돌아 다니다 보면 저에 글이 이곳저곳에 있더군요~ ^^;
많이 읽어 주시고 공부하시는 분들께 감사드리며, 앞으로 더욱 다양
한 주제로 강좌 활동을 할까 합니다.
지금 작업(막노동)하다가 날새고 글이 써질려나 싶네요?
PS. -------------------------------------------------------------
이글의 모든 저작권은 이준곤(LeeChen)에게 있으면 본인의 허락없이
불법적으로 도용하거나 다른 곳에 기재할 수 없습니다. 또한 처음 MFC
를 다루는 분이나 DirectX를 기본적으로 하시는 분의 눈높이에 맞추어
작성되어 있음을 밝힘!(실력이 좋으신 분은 안읽어도 되요~ ^^;).
-----------------------------------------------------------------
1. 다이렉트를 생성을 해야 하는데?
MFC를 사용하면서 초보자로서 처음문제가 어디에 다이렉트 엑스의 초
기화를 어느부분에 해야 할까? 어떤 클래스의 생성자에다 놓아야 할까
? 아니면 별도의 생성이나 초기화를 하기 위한 메세지가 존재하는 것
은 아닐까? 이런생각을 합니다.
# 프로그래머가 알아야할 명언 -----------------------------------
프로그래머가 생각한 모든 생각은 모두 프로그램으로 제작이 가능하다.
그러므로 지금 생각하는 것에 대해 잘안된다면 그것은 길을 발견을 못
했을뿐! 언젠가는 그것을 직접 제작할 수 있다.
-----------------------------------------------------------------
그렇다면 다이렉트 엑스를 초기화하기 위한 메세지는 어떤것인 길을
찾아 보자~
MFC 3편의 강좌에 이번에 윈모드로 제작은 View를 중심으로 제작을 한
다고 했다. 그렇다면 눈치가 있는 독자라면 클래스 위자드를 view 클
래스에 맞추어 놓고 앞으로 제작될 메세지들을 입력할 준비를 하고 있
을 것이다.
윈도우즈나 다이알로그 박스의 처리 방법을 알아 보자~
일단 수많은 윈도우즈가 화면에 떠있다. 그리고 그속에서 자신이 제
작한 다이알로그나 윈도우즈가 뜰때 처음 한번은 생성과 동시에 화면
에 보여지게 된다. 그리고 그 다음부터는 변화된 것만 윈도우즈자원에
메세지를 보내어 변화된 부분을 갱신해준다. 이것이 GUI 의 핵심 알고
리즘 즉, 커널의 이부분에 해당하는 부분이라고 할수 있는데 하여간
깊이 들어갈 필요없이 여기까지만 이야기 하고(궁금하신 분은 시스템
프로그램이나 운영체제에 대해 관련 서적이 서점에 즐비하므로 여기서
번역서적은 쓰레기이고 원서들을 사보시는 것이 있어요~ 책은 빨강색,
노랑색, 파랑색으로 많이 나와 있더군요~ ^^;) MFC의 메세지 구조도
최초의 초기화를 해주는 부분과 나중에 갱신이 되는 부분, 그리고 필
요시 유저의 강제메세지나 어떤 외부의 메세지로 인해 변화를 갱신하
기위한 메세지로 나위어 집니다.
#참고
윈도우즈 메세지 관련된 정보는 윈도우즈 NT 서적이 자세히 나와 있으
므로 윈도우즈 NT관련 프로그래밍 책을 참고 하세요~ (경제가 어려우
니 책을 사시지 마시고 도서관이나 서점에서 읽어서 참고만하세요~
그럼 도움이 될겁니다. 여유가 있으신 분은 NT관련 서적도 한권은 가
지고 계시는 것도 ... ^^; )
그렇다면 일단 최초에 생성을 하면서 단한번만 메세지가 발생되는 함
수를 만들어 보자면 역시 클래스 위자드로 가세요~ (이미 가 있다군요
~)
메세지중에 OnInitialUpdate를 선택해서 보면
void 클래스야View::OnInitialUpdate()
{
CView::OnInitialUpdate();
// 다이렉트 엑스를 생성한다. 640x480의 크기로
m_DD.Create (*this, 640, 480);
// 파레트를 생성하고
m_Palette.Create ();
m_DD.SetPalette (m_Palette);
// 유저가 사용할 평면을 생성
m_Surface.Create();
............
............
}
보통 보여주기 관련 클래스는 CView에서 상속을 받습니다. 그러니
CView의 형을 참고하는 것은 당근이죠? 다이렉트엑스는 하나의 프로그
램에 한번만 생성이 되니 위의 메세지가 이조건에 맞으니 필요조건인
것과 동시에 충분조건이죠~ (잉? 필요는 아닌듯~~--;)
2. 찍어 주기도 해야 하는데...
화면에 하나의 변화가 생기면 그것을 그려주는 메세지는 당연이 있어
야 화면에 무언가가 등장합니다. 없어도 되지만 그래도 있으면 ....
그러므로 이것을 가능하게 해주는 메세지를 찾아 보자면 (뒤적뒤적~)
잉? 누구죠? Paint를 쓰시다고 하신분이?
Paint도 맞긴합니다만 제가 여기서 구분을 별도록 짖기는 뭐하지만 인
위성문제로 Paint와 Draw를 구분을 짓는데 일단 자연적인 것을 추구하
는 필자로썬 Draw를 쓰려고 합니다.
void 클래스맞아View::OnDraw(CDC* pDC)
{
CMfcddex3Doc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
}
요렇게 생성이 되어 있죠? 이부분은 바꾸거나 추가할건 없습니다. 다
만 독자님들이 추가하실 것이 있으시다면 추가해넣으셔도 됩니다.
그렇다면 여기서 실제로 게임을 진행하는 부분은 어느 부분일까?
앞서배운 전체모드 MFC를 생각해보자 거시서는 어플리케이션 클래스에
화면을 복구하는 함수를 만들어 마치 도스의 게임을 제작하듯 제작을
했다. 이번에도 다를 것은 없다.
도스에서 게임을 제작할때 Main에 몽땅 집어 넣는 방법처럼 다음 함수
는 그러한 방식으로 코딩이 되어 있긴 한데
BOOL 클래스마져View::Main()
{
// if (!((CMainFrame*)m_pMainWnd)->m_bActive)
// return FALSE;
// 활성화가 되어 있느냐?에 관련된 변수의 값을 참고하는 것인데
// 이프로그램에서 배경을 복구하는데 필요없다.
DWORD thisTickCount; // 시간을 채크하기위한
RECT rcRect;
DWORD delay[4] = {50, 78, 13, 93};
int i;
PALETTEENTRY pe[256]; // 파레트를 담기위한
HRESULT ddrval;
// 현재 시간을 보간하고
thisTickCount = GetTickCount();
for(i=0; i<3; i++)
{
if((thisTickCount - m_lastTickCount[i]) > delay[i])
{
// Move to next frame;
m_lastTickCount[i] = thisTickCount;
m_currentFrame[i]++;
if(m_currentFrame[i] > 59)
m_currentFrame[i] = 0;
// Added to move the sprites.
if (++m_xpos[i] > (640-64))
m_xpos[i] = 0;
if (++m_ypos[i] > (480-64))
m_ypos[i] = 0;
}
}
// 640x480의 한프래임을 가져오기 위한 그림 크기
rcRect.left = 0;
rcRect.top = 0;
rcRect.right = 640;
rcRect.bottom = 480;
while( 1 )
{
ddrval = m_DD.BackBuffer().BltFast (0, 0, m_Surface, rcRect,
DDBLTFAST_NOCOLORKEY );
if( ddrval == DD_OK )
{
break;
}
if( ddrval == DDERR_SURFACELOST )
{
restoreAll();
}
if( ddrval != DDERR_WASSTILLDRAWING )
{
return TRUE;
}
}
if(ddrval != DD_OK)
{
return TRUE;
}
for(i=0; i<3; i++)
{
rcRect.left = m_currentFrame[i]%10*64;
rcRect.top = m_currentFrame[i]/10*64 + 480;
rcRect.right = m_currentFrame[i]%10*64 + 64;
rcRect.bottom = m_currentFrame[i]/10*64 + 64 + 480;
while( 1 )
{
ddrval = m_DD.BackBuffer().BltFast (m_xpos[i], m_ypos[i],
m_Surface,rcRect, DDBLTFAST_SRCCOLORKEY );
if( ddrval == DD_OK )
{
break;
}
if( ddrval == DDERR_SURFACELOST )
{
restoreAll();
}
if( ddrval != DDERR_WASSTILLDRAWING )
{
return TRUE;
}
}
}
// Flip the surfaces
while( 1 )
{
ddrval = m_DD.Paint (); // 찍어~ 무조건 찍어~
if( ddrval == DD_OK )
{
break;
}
if( ddrval == DDERR_SURFACELOST )
{
restoreAll();
}
if( ddrval != DDERR_WASSTILLDRAWING )
{
break;
}
}
return TRUE;
}
(이거 MFC 맞아요? 모양만 MFC 아니예요? ) 울랠래~ 분명히 이방법을
사용하면 게임제작툴을 SDI로 구성하고 다이렉트의 평명을 잡고 복잡
한 처리없이 인터페이스 부분을 신경써서 툴을 제작할 수 있다.
다시 정리를 하자면~
1. 메세지를 구성하는 방법을 알아야 한다.
2. 다이렉트 엑스를 MFC에 응용하는 벙법은 다양한다.
1) 다이알로그로 생성해서 제작
2) 도규먼트와 뷰가 없이 제작한다.
3) 윈도우즈 모드에서 충돌없이 사용한다.
3) 기타 방법
3. 어디에서 생성하고 어디서 소멸을 하는지를 파악한다.
[ 메세지 분석을 통한 위치결정 ]
4. 응용 프로그램실력을 쌓는다.
제가 위의 2번에서 2),3)을 다루어 보았는데 앞으로 기회가 있다면
기타방법을 알려 두리고 보다 다양한 방법이 나와 독자분들께서 선택
을 해서 사용할 수 있는 때가 오기를 바라면서 다이렉트 엑스를 MFC
에서 사용하자편을 마감하겠습니다.
앞으로 보다 빠른 방법으로 화면에 찍는 방법, 3차원 음향효과 처리
방법, 기타 제가 가지고 있는 정보를 기술해 보도록 하겠습니다.
이미 알고 계시는 분들은 아무것도 아니지만 처음 공부하거나 접하는
분들에게 마땅한 자료가 없어 고생하시는 분들을 생각하면 별 도움
안되는 글을 적어 보았습니다. ( ?? 어색한 문구.... )
=================================================================
98. 3. 23 아침에...
초야에서
소망합니다.
모든이들이 잘 되기를 소망합니다.
나는 어렵고 힘들어도 잘 되기를 소망합니다.
기도합니다.
모든 이들이 고통 없길 기도합니다.
나는 힘들어 하지만 그들은 항상 웃기를 기도합니다.
사랑합니다.
내가 아는 모든 이들을 사랑합니다.
나를 사랑않는다 해도 나는 그들을 사랑합니다.
- LeeChen -
#1521 서성칠 (ssc7 )
[강좌] LeeChen:DX용 스프라이트 관리자 03/26 03:22 298 line
=================================================================
안녕하세요~ 이준곤(LeeChen)입니다.
=================================================================
봄햇살이 무척이나 좋게 느껴지는 하루였죠? 오늘은 스프라이트 관리
에 관한 질문을 저에게 많이들 하셔서 이렇게 스프라이트 관련된 내용
으로 다시 글을 씁니다.
스프라이트 관리 방법에는 여러가지가 있는데 그중에서 한가지 방법
을 다루도록 하겠습니다. 앞으로 몇회로 다루게 될지는 모르지만....
일단 오늘은 개괄적인 내용을 다루도록 하죠~
PS. -------------------------------------------------------------
이글의 모든 저작권은 이준곤(LeeChen)에게 있으면 본인의 허락없이
불법적으로 도용하거나 다른 곳에 기재할 수 없습니다. 또한 처음 MFC
를 다루는 분이나 DirectX를 기본적으로 하시는 분의 눈높이에 맞추어
작성되어 있음을 밝힘!(실력이 좋으신 분은 안읽어도 되요~ ^^;).
-----------------------------------------------------------------
강의 주제 : DirectX용 스프라이트 관리자를 만들자~
강의에 앞서 앞으로 다룰 내용은 트랙이나 필드게임을 제작하길 원하는
분들을 대상으로 다루고 있습니다. 그리고 주된 내용은 캐릭터를 움직
이고 점프하고 달리는 등등의 행동을 다루게 될것입니다.
다음은 스프라이트 관리자를 제작하면서 들어갈 기능과 사용방법을
적어 놓았습니다.
1. 유저가 선택된 키값에 따라 달리거나 뛰게 할수 있다.
2. 어떤 상태에 따라 프레임 보존을 결정하게 된다.
3. 원하는 크기의 이미지를 준비한다. 여기서 사용한 이미지는
3D Studio로 제작된 달리는 남자의 렌더링된, 각각의 방향마다
8프레임의 그림이다.
4. 유저가 오브젝드를 생성할때는 다음과 같이 하면 된다.
// 달리는 사람을 가져오기 위한 적절한 크기
// 1 frame=1 or more view positions
Frame uomocorsa_frame[8]={
Frame(100,100,0,10),Frame(100,100,200,10),
Frame(100,100,400,10),Frame(100,100,600,10),
Frame(100,100,800,10),Frame(100,100,1000,10),
Frame(100,100,1200,10),Frame(100,100,1400,10)
};
// Sequence of indexes to be swept for animation
DWORD uomocorsa_index[8]={0,1,2,3,4,5,6,7};
// Sequence of delays for any frame
DWORD uomocorsa_delay[8]={50,50,50,50,50,50,50,50};
// Build one state, that of Running
State
uomocorsa(uomocorsa_frame,uomocorsa_index,uomocorsa_delay,7);
// Build a Sprite, able only to run...
CSprite uomo(&uomocorsa);
설명 :
프래임을 uomocorsa_frame[]라고 배열로 잡습니다. 해당프래임의
요소를 Frame(w,h,ypos,pics_per_row) 함수를 이용해 채워집니다.
여기서 w,h는 스프라이트의 크기이며, ypos는 소스 비트맵의 y위치를
나타냅니다. pics_per_row는 가로로 그림이 몇개가 있는가를 나타냅
니다.
uomocorsa_index[] 와 uomocorsa_delay[] 는 각각의 프래임의 번호
와 프래임을 담아두는 배열변수입니니다. 달리는 프래임에 해당하
는 각각의 프래임마다 시간이 있겠죠~ 여기서는 50이라는 값으로 통일
해두었습니다.
여기까지가 CSprite를 사용하는 방법에 대해 이야기를 했습니다.
(우째 내용이 서투른 내용이였습니다.~)
5. 그렇다면 이번에는 유저가 그림을 읽어와야 하는데 어떻게 하면
될까요?
// Load pinkman bitmap
lpDDSUomo=DDLoadBitmap(lpDD,"예제.bmp",0,0);
if (lpDDSUomo==NULL)
return InitFail(hwnd,"DDLoadBitmap UomoRosa");
// Load surf.2
lpDDS2=DDLoadBitmap(lpDD,"배경.bmp",0,0);
if (lpDDS2==NULL) return InitFail(hwnd,"DDLoadBitmap 2");
ddck.dwColorSpaceLowValue=255;
ddck.dwColorSpaceLowValue=0;
ddrval=lpDDSUomo->SetColorKey(DDCKEY_SRCBLT,&ddck);
이부분은 어디서 많이 보던 내용인데...^^;
예~ 바로 다이렉트 액스의 셈플중에 자세히 살펴 보시면 비슷한 내용
이 있는 부분이 있을 겁니다.
위에서 보면 255번색을 투명 컬러로 잡아서 사용하는 것을 알수 있죠
6.이번에는 스프라이트를 생성하면
// INIT Sprite
for (i=0;i<8;i++) uomocorsa_frame[i].AssignSrcSurf(lpDDSUomo);
uomo.AssignDestSurf(lpDDS3);
uomo.AssignBackSurf(lpDDS2);
uomo.xpos=320;
uomo.ypos=240;
8개의 프래임에 해당하는 스프라이트를 일단은 뒤의 서페이스에서 담
아 두고 해당좌표를 정의하고 단일 프래임으로 돌아가는 예제라 이렇
게 했습니다. 복잡한 더불이상의 프래임이 돌아가면 조금 코드를 바
꾸어야 겠지요~
7. 이제 남은 것은 찍는 것!
// UPDATE & DRAW
uomo.Update();
uomo.Draw();
// Do stuff like flipping surface etc
// Replace BACKGROUNDS
ddrval=uomo.ReplaceBack();
8. 시간에 따라 적절하게 찍어주며, xpos,ypos 와 currviewindex
에 해당하는 값에 따라 관리를 해준다. (...--; 정말 어색하다~)
하하~ 이거~ 내용이 이상하게 돌아가는 듯한 내용이죠?
읽고 나도 우째? 남는 것은 없을까? 저도 쓰면서 남는 내용없습니다.
그렇다면 어디 소스를 분석해 보도록 하죠~
class Frame는 단순히 각각의 프래임의 위치나 크기에 해당하는
프래임 정보를 가지고 있습니다.
class Frame
{
friend class State;
friend class CSprite;
public:
Frame(DWORD,DWORD,DWORD,DWORD);
~Frame();
void AssignSrcSurf(LPDIRECTDRAWSURFACE);
private:
DWORD width,height,bmpypos,numperrow;
LPDIRECTDRAWSURFACE srcsurf;
};
또하나 추가하자면 해당 프래임의 평면도 가지고 있어야 겠지요~
이 클래스는 하나의 스프라이트의 상태값에 영향을 주며, 실제로
찍히는 부분에도 영향을 주죠~
스프라이트가 찍히면서 가지고 있어야 할 정보는 과연 무얼까요? 보통 상태를
나태내는 정보라고 하는데 아주 간단하게 현재 자기자신이 어떤 정보인지 즉,
몇번째 프래임인지 번호(또는 이름)이 있어야 갰지요~ 그리고 얼마동안 살아
있어야 하는지 시간을 알고 있어야 겠지요~ 그리고 최대 자신이 보유한 프래
임의 갯수는 몇개인지는 알고 있어야 겠지요~
class State
{
friend class CSprite;
public:
State(Frame*,DWORD*,DWORD*,DWORD);
~State();
private:
DWORD *frindex;
DWORD *frdelay;
DWORD maxindex;
Frame *frarr;
};
이클래스는 앞으로 나올 스프라이트 클래스에 영향을 주는 클래스 입니다. 바로
앞서 이야기한 내용의 값들을 찍는 루틴에 영향을 주아야죠~ 가지고 있는 다고
보두 해결되는 것은 아니겠죠~
class CSprite
{
public:
CSprite(State*);
~CSprite();
HRESULT Draw();
void AssignDestSurf(LPDIRECTDRAWSURFACE);
void Update();
void AssignBackSurf(LPDIRECTDRAWSURFACE);
HRESULT ReplaceBack();
DWORD xpos,ypos;
DWORD currstate;
int currviewindex;
float scale;
float timescale;
private:
DWORD laptime;
DWORD currindex;
State *states;
LPDIRECTDRAWSURFACE destsurf,backsurf;
};
그렇게복잡한 클래스들이 아니라 이해하는데 어려움이 없을 거라
생각됩니다. 그럼 다음 코드를 보죠~ 코드라고 해서 복잡한 내용은
없습니다.
주된 부분만 보자면 많은 그림이 있는 것에서 가지고 오는 부분을
살펴보자면
HRESULT CSprite::ReplaceBack()
{
RECT dr;
State *ps=&(states[currstate]);
// 현 스프라이트의 상태를 읽어 오고
Frame *pf=&(ps->frarr[ps->frindex[currindex]]);
// 각각의 프래임에 대한 번호를 파악하고
dr.left=xpos; dr.top=ypos;
dr.right=xpos+(pf->width)-1;
dr.bottom=ypos+(pf->height)-1;
return destsurf->Blt(&dr,backsurf,&dr,0,NULL);
}
Update함수는 주로 해당 프래임이 시간이 유지되었는가?를
파악해서 다음 프래임의 그림을 찾아 주는 함수입니다.
알고리즘은 아주 간단하게 되어 있으니 살펴 보세요~
void CSprite::Update()
{
State *ps=&(states[currstate]);
if (timescale*(GetTickCount()-laptime) > ps->frdelay[currindex])
{
currindex++;
if (currindex>ps->maxindex) currindex=0;
laptime=GetTickCount();
}
}
위의 함수로 화면에 찍힐 스프라이트의 행동이 갱신되었다면
화면에찍어주어야 겠지요~
HRESULT CSprite::Draw()
{
LPDIRECTDRAWSURFACE ss;
RECT sr,dr;
// 현 정보를 읽어 찾아 준다.
State *ps=&(states[currstate]);
Frame *pf=&(ps->frarr[ps->frindex[currindex]]);
// 해당프래임의 실제 데이타(그림)을 찾아 준다.
ss=pf->srcsurf;
// 프래임의 크기를 파악해서
dr.left=xpos; dr.top=ypos;
dr.right=xpos+(pf->width)-1;
dr.bottom=ypos+(pf->height)-1;
sr.left=(currviewindex % (pf->numperrow))*pf->width;
sr.top=pf->bmpypos+(currviewindex / (pf->numperrow))*pf->height;
sr.right=sr.left+pf->width-1;
sr.bottom=sr.top+pf->height-1;
return destsurf->Blt(&dr,ss,&sr,DDBLT_WAIT | DDBLT_KEYSRC,NULL);
// 찍자~
}
와우..뭐~ 그것도 아무것도 아니죠~ 관리자니 엔진이니 해봐야 별거
없어요~ 복잡하게 만드는 사람이 이상한거요~ 간단하고 단순하게 제작
해서 버그없이 돌어간다면...그것만드로도...^^;
오늘은 우째 부실부실 하다는 내용이 앞서지만...그래도 혹시나 이러한
내용이 다이렉트 엑스를 배우고자 하시는 분들에게 조금이나마 도움이
될까~ 싶어서 올립니다.
광고>
하이텔 게제동에 이자료를 올립니다. 소스화일과 그림 화일이
있는데 컴파일해서 직접 살펴 볼수도 있습니다.
키보드로 조작해서 스프라이트가 돌아가는 것을 확인해보시길
바랍니다. 그리고 소스를 분석해보세요~ (위의 내용과 다른 것은
전혀 없습니다.)
그럼...수고들 하세요~
산장에서 어느 한적한 오후에~
1998. 3. 25.