Bài tìm hiểu về DIRECT-X

1


Mục Lục

2


Tìm hiểu về DirectX :
Giới thiệu

OpenGL, Direct3D hay rộng hơn là DirectX là một trong những giao diện lập trình ứng dụng
(API) về đa phương tiện thông dụng nhất hiện nay. Trong suốt quãng thời gian phát triển
của mình, song song với sự phát triển của hệ thống máy tính hiện đại: giá thành ngày càng
giảm, sức mạnh được tăng vọt – lấy ví dụ như 20 năm về trước, bộ nhớ máy tính (RAM) cá
nhân chỉ khoảng 32MB đã là rất “vĩ đại”; thế nhưng so với hiện nay, bộ nhớ trung bình của
một máy tính thường dao động từ 4 - 8GB (gấp hàng trăm lần); hay sự phát triển của các thế
hệ hệ điều hành: MS-DOS, Windows 3.1, Windows 95 … cho đến Windows 10 mới nhất.
Song song đó, các thư viện đồ họa cũng phát triển như vũ bão, tại mỗi thời điểm khác nhau,
ưu thế của mỗi thư viện có thể khác nhau. Nhưng tựu chung lại cũng nhằm mục đích tận
dụng tối đa sức mạnh công nghệ tại thời điểm đó. Trải qua bao thăng trầm, đồ họa máy tính
hiện đại đã khác rất rất xa so với thời điểm mới ra đời.

The Elder Scrolls: Arena (1994)

3


GTA V (2015)

Nói một cách đơn giản DirectX là một phần mềm được thiết kế bởi Microsoft để có thể giao
tiếp với các linh kiện phần cứng trên PC. Nói một cách chi tiết, nó là tập hợp những giao diện
lập trình ứng dụng, hay còn được gọi tắt là API, được thiết kế để xử lý các công việc liên
quan đến render các vector đồ họa 2D hay 3D, render các đoạn video và chơi các đoạn âm
thanh trên nền tảng Windows.
Đây chính là đối thủ nặng kí nhất với OpenGL, một bộ API tập trung về đồ họa khác được
giới thiệu vào năm 1992, đây cũng là một mã nguồn mở và vẫn đang được tiếp tục phát
triển bởi tập đoàn công nghệ Khronos Group. Và trong khi OpenGL là một API đa nền tảng,
nhưng nó lại không có lợi thế của việc chỉ dành riêng cho nền tảng Windows.
DirectX xuất hiện lần đầu trên Windows 95. Vào thời điểm đó, phần lớn các game thủ trên
PC vẫn còn dùng nền tảng DOS, thứ mà cho phép các nhà phát triển có thể nói chuyện trực
tiếp với các linh kiện PC như card âm thanh, card đồ họa, bàn phím và chuột.
Những người chơi game PC lâu năm chắc chắn vẫn còn nhớ thời mà còn phải chỉnh file
Config.sys hay Autoexec.bat để có thể thiết lập đúng các môi trường cài đặt để một số game
nhất định có thể hoạt động tốt (IRQ và DMA cũng phải được edit lại, nhưng đó lại là chuyện
khác). Windows 95 không hề có khả năng giao tiếp trực tiếp với các linh kiện – cho đến khi
Microsoft phát triển bộ API DirectX.
Lúc đầu, DirectX không được quá nhiều người quan tâm đến, do các nhà phát triển vẫn còn
phụ thuộc vào OpenGL và khả năng lập trình tốt trên nền tảng DOS. Nhưng rồi bộ API đồ
họa của Microsoft dần dần đã lấy được niềm tin của các nhà phát triển khi họ phát hiện rằng
4


nó sẽ không bao giờ biến mất.
Vì vậy, DirectX dần dần đã đẩy được OpenGL ra nơi khác vào thời điểm mà phiên bản 9
(DX9) ra mắt vào năm 2002. Windows XP gần như đã tăng tốc độ phát triển của DirecX khi
đây là phiên bản Windows cực kì ổn định và vẫn còn được dùng rộng rãi trên toàn cầu.
Windows 10 cũng được đánh giá là nổi tiếng không kém, và đi cùng với nó là phiên bản mới
nhất trong dòng DirectX, DirectX 12.


Thư viện DirectX

DirectX là một tài sản của tập đoàn Microsoft. Logo của bộ thư viện này đơn giản chỉ là tên
gọi DirectX đi cùng tên của công ty.

Mirosoft DirectX là một tập hợp các API (giao diện lập trình ứng dụng) để xử lý các tác vụ
liên quan đến đa phương tiện, đặc biệt là lập trình game và video, trên nền tảng Microsoft.
Thuở ban đầu, tên gọi của tất cả các API nay đều được bắt đầu bởi tiền tố Direct, ví dụ
như Direct3D, DirectDraw, DirectMusic, DirectPlay, DirectSound …
Tên gọi DirectX đôi khi được rút gọn chỉ còn X (X đứng trước tên của những API tương ứng).
Khi Microsoft tiến hành phát triển một hệ máy chơi game mới, kí tự X được dùng trong
từ Xbox – tên hệ máy chơi game – để ám chỉ việc thế hệ máy chơi game này được xây dựng
trên những công nghệ của DirectX. Kí tự X sau đó được dùng để đặt tên cho những API được
thiết kế dành riêng cho Xbox như XInput, XACT (Audio Creation Tool) … trong khi tiền tố
Direct được Microsoft sử dụng để đặt tên cho các API dành cho Windows như Direct2D,
DirectWrite …
Direct3D (các API đồ họa 3D trong bộ thư viện DirectX) được sử dụng rộng rãi trong việc
phát triển game cho Windows, Sega Dreamcast, Microsoft Xbox, Microsoft Xbox 360 và
Microsoft Xbox One. Direct3D cũng được dử dụng cho những ứng dụng thiết kế đồ họa, xử
lý ảnh. Và cũng bởi vì Direct3D là thành phần tiêu biểu cho bộ thư viện DirectX, nhắc tới
DirectX là nhắc tới Direct3D, vì vậy đôi khi tên gọi DirectX và Direct3D bị đánh đồng với
nhau.
Thư viện DirectX được tải về theo 2 cách:
• DirectX Runtime Library: bao gồm tập hợp các file DLL cần thiết dành cho những ứng
dụng sử dụng thư viện DirectX vận hành được. Bộ thư viện này thích hợp cho người
dùng cuối. Ví dụ như DirectX 9.0c Runtime Library.
• DirectX SDK (Software Development Kit) được phát hành dành cho những nhà phát
triển / lập trình viên muốn sử dụng sức mạnh của bộ thư viện DirectX. DirectX SDK
bao gồm DirectX Runtime Library cũng như các thư viện, các file header cần thiết, tài

liệu và ví dụ minh họa cho các tính năng.Kể từ Windows 8, DirectX SDK được tích hợp
luôn trong bộ Windows SDK.

5


Riêng với Direct3D 9Ex, Direct3D 10 và Direct3D 11 chỉ có thể hoạt động trên các máy tính
cài Windows Vista trở về sau do những phiên bản này được xây dựng trên kiến
trúc Windows Display Driver Model (WDDM) – kiến trúc đồ họa này được giới thiệu trong
Windows Vista.
Quá trình phát triển

Cuối năm 1994, khi Microsoft chuẩn bị công bố hệ điều hành tiếp theo của họ - Windows 95.
Tại thời điểm đó, 3 nhân viên của Microsoft - Craig Eisler, Alex St. John, và Eric Engstrom - lo
lắng về việc các lập trình viên có xu hướng đánh giá MS-DOS là nền tảng tốt hơn cho lập
trình game, và như vậy sẽ có ít tựa game được phát triển cho Windows 95.
Lý do bởi vì DOS cho phép lập trình viên can thiệp trực tiếp vào các thành phần của hệ thống
như: video cards, bàm phím, chuột, thiết bị xuất âm thanh …. Trong khi đó, Windows 95 với
kiến trúc chặt chẽ hơn, không cho phép điều này xảy ra. Trong khi chưa đầy 1 tháng nữa
Windows 95 sẽ ra mắt, Microsoft cần một chìa khóa để giải quyết mâu thuẫn này. Eisler
(development lead), St. John, và Engstrom (program manager) đã làm việc với nhau, đề xuất
một giải pháp mà họ đặt tên là DirectX.
Phiên bản đầu tiên của DirectX phát hành vào tháng 9 năm 1995 với tên gọi Windows
Games SDK – cũng là sự thay thế cho DCI và WinG API trên Windows 3.1. Nhờ có DirectX
(được tích hợp vào trong Windows 95 trở về sau), ứng dụng có thể tận dụng sức mạnh phần
cứng để xử lý nhiều tác vụ đa phương tiện. Eisler có đề cập tới sự “điên cuồng” trong việc
xây dựng DirectX 1 tới 5 trên blog của anh ta.

Craig Eisler


Alex St. John
6


Eric Engstrom
Việc chuyển dịch sang DirectX khởi đầu khá chậm chạp vì những lo ngại về sự thay thế của
WinG, hiệu năng của DirectX – do Windows thời điểm này được xây dựng trên nền DOS và
sự ra đi của nhiều lập trình viên DOS.
DirectX 2.0 trở thành một thành phần của Windows trong phiên bản Windows 95
OSR2 và Windows NT 4.0 vào giữa năm 1996. Do Windows 95 còn quá mới mẻ lúc này nên
có rất ít tựa game được phát hành cho nó. Microsoft đã triển khai những chiến dịch quảng
bá mạnh mẽ cho DirectX nhằm đánh tan sự hoài nghi của giới lập trình viên về nền tảng này.
Tại sự kiện Computer Game Developers Conference năm 1996, Microsoft lần đầu tiên giới
thiệu Direct3D và DirectPlay song song với việc minh họa chế độ chơi mạng của
game MechWarrior 2.
Thách thức đặt ra cho nhóm phát triển DirectX là làm thế nào DirectX có thể tương thích với
nhiều phần cứng khác nhau. Những phần cứng có thể kể đến như những loại card đồ họa,
card âm thanh, motherboard, CPU, thiết bị nhập, xuất … Tất cả các phiên bản DirectX được
phát hành đều phải được kiểm tra (ở cả bản beta và bản cuối cùng) một cách kỹ càng để
đảm bảo tương thích tốt với phần cứng / phần mềm. Ngoài ra, nhóm phát triển cũng gửi
những bản mẫu đến các đối tác để chắc chắn phiên bản sắp phát hành tương thích với
những phần cứng mới này.
Trước DirectX, OpenGL là một thành phần của Windows NT. OpenGL tại thời gian này yêu
cầu phần cứng cao hơn và tập trung vào các giải pháp kỹ thuật, CAD. Direct3D được
Microsoft định hướng là thành phần gọn nhẹ hơn OpenGL và tập trung chủ yếu vào game.
Khi các game 3D bắt đầu bùng nổ, OpenGL cũng được phát triển để hỗ trợ tốt hơn cho việc
lập trình game, và giờ đây lập trình viên được lựa chọn giữa OpenGL hay Direct3D cho ứng
dụng của họ. Cũng từ đây, cuộc chiến không hồi kết giữa OpenGL và Direct3D bắt đầu.
Nhiều tranh luận được đưa ra giữa việc xây dựng ứng dụng hỗ trợ đa nền tảng với OpenGL
hay chỉ hỗ trợ duy nhất Windows với Direct3D.

Trên các hệ máy chơi game – console – được phát hành bởi Microsoft, DirectX được tùy
biến lại dưới sự hợp tác của Nvidia – đối tác phần cứng cho 2 hệ máy chơi game Xbox,
Xbox360 – và AMD – hệ máy XboxOne.
Năm 2002, Microsoft phát hành DirectX 9, hỗ trợ lập cho việc lập trình vertex và pixel
shader – Shader Model 2.0. Phiên bản Direct9.0c với Shader Model 3.0 được phát hành
không lâu sau đó, vào tháng 8 năm 2004.
Tháng 4 năm 2005, DirectShow được gỡ khỏi DirectX và chuyển qua tích hợp vào Microsoft
Platform SDK.

7


Bảng tổng hợp dưới đây liệt kê toàn bộ các phiên bản DirectX, thời điểm ra mắt và các sự
kiện liên quan.
Phiên bản
Số phiên bản
DirectX
DirectX
4.02.0095
1.0
DirectX
2.0
DirectX
4.03.00.1096
2.0a
4.04.00.0068
DirectX
3.0
4.04.00.0069
DirectX

3.0a
DirectX
3.0b
DirectX
4.0
DirectX
5.0
DirectX
5.2
DirectX
6.0
DirectX
6.1
DirectX
6.1a
DirectX
7.0
DirectX
7.0a
DirectX
7.1
DirectX
8.0
DirectX
8.0a
DirectX
8.1

4.04.00.0070


Hệ điều hành và ghi chú

30 Tháng 9, 1995
Chỉ được phát hành cho một số ứng
1996
dụng hãng thứ ba
Windows 95 OSR2 và Windows NT
5 Tháng 6, 1996
4.0
15 Tháng 9, 1996
Gói cập nhật của DirectX 3.0, bao
1996
gồm Direct3D 4.04.00.0069
Windows NT 4.0 SP3 (và cao hơn)

4.05.01.1600 (RC00)
4.05.01.1998 (RC0)

Bản cập nhật nhỏ sửa các lỗi trong
phiên bản Windows 95 tiếng Nhật
Phiên bản này chưa bao giờ được
phát hành
Phiên bản thử nghiệm dành cho
Windows 2000
Windows 95
Windows 98

4.06.00.0318 (RC3)

Windows CE cho máy Dreamcast


4.04.00.0070
n/a
4.05.00.0155 (RC55)

4.06.02.0436 (RC0)
4.06.03.0518 (RC0)
4.07.00.0700 (RC1)
4.07.00.0700
4.07.00.0716 (RC0)
4.07.00.0716 (RC1)
4.07.01.3000 (RC1)

4.08.01.0810
4.08.01.0881 (RC7)

Tháng 12, 1996
Tháng 12, 1996

4 Tháng 8, 1997
5 Tháng 5, 1998
25 Tháng 6, 1998
7 Tháng 8, 1998
3 Tháng 2, 1999

Windows 98 SE
Windows 2000

Windows ME


4.08.00.0400 (RC10)
4.08.00.0400 (RC14)

Ngày phát hành

5 Tháng 5, 1999
22 Tháng 9, 1999
17 Tháng 2, 2000
8 Tháng 3, 2000
2000
14 Tháng 9, 2000
12 Tháng 11, 2000

Phiên bản cuối cùng hỗ trợ
5 Tháng 2, 2001
Windows 95 và software rendering
Windows XP, Windows XP SP1,
25 Tháng 10, 2001
Windows Server 2003 và Xbox
Dành cho các hệ điều hành cũ hơn 8 Tháng 11, 2001
8


DirectX
8.1a
DirectX
8.1b
DirectX
8.2
DirectX

9.0
DirectX
9.0a
DirectX
9.0b
DirectX
9.0c

4.08.01.0901 (RC?)
4.08.01.0901 (RC7)
4.08.02.0134 (RC0)

(Windows 98, Windows ME và
Windows 2000)
Phiên bản này cũng cập nhật cho
Direct3D (D3d8.dll)
Sửa lỗi của DirectShow trên
Windows 2000 (Quartz.dll)
Tương tự như DirectX 8.1b, chỉ
nâng cấp DirectPlay lên 8.2

2002
25 Tháng 6, 2002
2002

4.09.00.0900 (RC4)

19 Tháng 12, 2002

4.09.00.0901 (RC6)


26 Tháng 3, 2003

4.09.00.0902 (RC2)

13 Tháng 8, 2003

4.09.00.0903
4.09.00.0904 (RC0)
4.09.00.0904

Windows XP SP2
4 Tháng 8, 2004
Xbox 360, Windows XP SP2, SP3,
Windows Server 2003 SP1 và
Windows Server 2003 R2

6 Tháng 8, 2004
21 Tháng 4, 2008

9 Tháng 2, 2005 phát hành phiên
bản 64-bit đầu tiên.
Phiên bản cuối cùng cho Windows
98 SE / ME được phát hành vào 13
tháng 12, 2006.
DirectX
4.09.00.0904 (RC0 của Phiên bản cuối cùng cho Windows
(cập nhật
DX 9.0c)
2000 được phát hành vào 5 tháng

định kỳ)
2, 2010.
Phiên bản hỗ trợ chính thức cho
Windows Vista được phát hành vào
tháng 4 năm 2006, cho Windows 7
vào tháng 8 năm 2009.

Phát hành mỗi 2
tháng từ tháng 10
năm 2004 đến tháng
8 năm 2007. Sau đó
phát hành mỗi quý
cho đến bản cuối
cùng vào tháng 6,
2010.

DirectX 10 6.00.6000.16386

30 Tháng 11, 2006

DirectX
10.1

6.00.6001.18000
6.00.6002.18005
6.01.7600.16385

DirectX 11 6.00.6002.18107
6.01.7601.17514
DirectX

11.1

6.02.9200.16384

Windows Vista
Windows Vista SP1, Windows
Server 2008
Windows Vista SP2, Windows
Server 2008 SP2
Windows 7, Windows Server 2008
R2
Windows 7 SP1, Windows Server
2008 SP2
Windows 7 SP1, Windows Server
2008 R2 SP1
Windows 8, Windows RT, Windows
Server 2012
9

4 Tháng 2, 2008
28 Tháng 4, 2009
22 Tháng 10, 2009
27 Tháng 10, 2009
16 Tháng 2, 2011
1 Tháng 8, 2012


DirectX
6.03.9600.16384
11.2

DirectX 12 10.00.10240.16384

Windows 8.1, Windows RT,
Windows Server 2012 R2
Windows 10, Xbox One

18 Tháng 10, 2013
29 Tháng 7, 2015

DirectX 4 chưa bao giờ được phát hành. Raymond Chen – trưởng bộ phận thiết kế phần
mềm của Microsoft – giải thích trong cuốn sách "The Old New Thing" của ông về sự kiện
này. Sau khi DirectX 3 phát hành, Microsoft tiến hành phát triển phiên bản DirectX 4 và 5
song song với nhau. Trong đó, DirectX 4 dự định sẽ là một bản cập nhật một số tính năng,
trong khi DirectX 5 dự định sẽ là một phiên bản lớn với nhiều cải tiến. Tuy nhiên, lập trình
viên tỏ ra không hào hứng với những tính năng sẽ được giới thiệu trong DirectX 4 dẫn tới
việc phiên bản này bị "xếp xó" và những tài liệu liên quan tới việc phân biệt 2 phiên bản này
cũng bị Microsoft loại bỏ.
Logo

Logo ban đầu có thiết kế mang hướng gần với ký hiệu cảnh báo vùng phóng xạ. Alex St.
John, trưởng bộ phát phát triển DirectX, xác nhận việc xây dựng logo dựa trên Manhattan
Project (dự án chế tạo bom nguyên tử trong chiến tranh thế giới hai) - tên mã của dự án
DirectX cũng là Manhattan Project - là có chủ đích, và thể hiện tham vọng vào DirectX và
anh em của nó là Xbox (cũng có logo tương tự) muốn thay đổi toàn bộ cục diện ngành công
nghiệp game. Tuy nhiên, Microsoft đã công khai bác bỏ ý kiến này, thay vào đó tuyên
bố logo này chỉ đơn giản là một thiết kế mang tính nghệ thuật.
DirectX 1.0 - 8.2
DirectX 9.0 - 12

Những thành phần tạo nên DirectX


Windows hỗ trợ Multimedia rất tốt chính là nhờ vào DirectX. DirectX không phải là một
“mẫu” phần mềm duy nhất mà là một tập hợp đa dạng của các hàm giao tiếp lập trình ứng
dụng (Application Programming Interface-API) của riêng Windows, cung cấp một bộ công cụ
đã chuẩn hoá các tính năng hỗ trợ cho đồ hoạ, âm thanh, việc cài đặt các ứng dụng, sự
tương tác của nhiều người cùng tham gia trong một trò chơi nối mạng.
DirectX được chia thành ba lớp (tầng): Lớp nền tảng (Foundation Layer), lớp phương tiện
(Media Layer) và lớp thành phần (Components Layer)
* Lớp nền tảng:
Foundation là phần cốt lõi của DirectX, nó là một tập hợp các API cấp thấp tạo nên cơ sở cho
những hoạt động multimedia hiệu năng cao trong Windows. Thông qua lớp nền tảng có thể
10


tác động đến các API sau:
+ DirectDraw: Quản lý bề mặt đồ hoạ.
+ Direct3D: Cung cấp tính năng 3D cấp thấp.
+ DirectInput: Hỗ trợ các thiết bị nhập, kể cả các Joystick thế hệ mới.
+ DirectSound: Cung cấp hiệu ứng âm thanh và bộ trộn tiếng.
+ DirectSound 3D: Giúp tạo hiệu ứng âm thanh 3D từ kiểu loa 2D thông thường.
+ DirectSetup: Giúp cài đặt các phần mềm, các Driver một cách tự động
* Lớp phương tiện:
Media Layer của DirectX bao gồm các API ở cấp ứng dụng, tận dụng khả năng của lớp nền
tảng. Các dịch vụ của lớp phương tiện này có tính độc lập với các thiết bị. Lớp phương tiện
này gồm có:
+ Direct3D: Cung cấp tập hợp các tính năng biểu diễn 3D.
+ DirectPlay: Hỗ trợ nhiều người cùng tham gia chơi game qua mạng.
+ DirectShow: Quản lý các Slide Show.
+ DirectAnimation: Cung cấp khả năng làm hoạt hình.
+ DirectModel: Cung cấp khả năng mô phỏng 3D.

* Lớp thành phần:
Components Layer là lớp trên cùng của DirectX, nó có thể tận dụng các tính năng của hai lớp
trên (Media và Foundation) bao gồm:
+ NetMeeting: Hỗ trợ làm việc theo nhóm trong mạng máy tính.
+ ActiveMovie: Bộ các công cụ quản lý và trình diễn phim MPEG, hỗ trợ việc chơi các file âm
thanh và phim ảnh.
+ NetShow: Hỗ trợ việc truyền các nội dung multimedia qua Internet.

Làm việc với DirectX
11


Rõ ràng DirectX hết sức quan trọng đối với cái “Sướng mắt, đã tai” cho nên chúng ta cần
quan tâm đến nó, để nó tận tụy phục vụ mình.
Cách đọc phiên bản Direct:
a) Cách thứ nhất:

Trong thư mục Windows của ổ đĩa khởi động, bạn mở thư mục System (đối với Win9x,
WinMe), hoặc System32 đối với Win XP.
+ Tìm file DDRAW.DLL. Bấm nút phải chuột vào file này, chọn Properties, chọn thẻ
Version trong hộp thoại.
+ Ở dòng File Version bạn sẽ đọc thấy dãy các con số tương ứng với phiên bản DirectX
đang sử dụng:
4.07.01.3000 DirectX 7.1
4.8.0.400 DirectX 8.0
5.1.2600.1106 DirectX 8.1
4.09.00.900 DirectX 9.0
Mỗi phiên bản Windows có một phiên bản DirectX tương ứng. Với Win98 là DirectX6.1;
WinMe, Win2000 là DirectX7.1; WinXP là DirectX8.0 và 8.1.
Hiện nay đã có DirectX 9.0 và 9.0b. Tuy nhiên không phải Card tăng tốc đồ họa nào cũng

phù hợp với nó.
b) Cách thứ hai:
Đơn giản hơn cách thứ nhất. Bạn chỉ cần mở Run trong menu Start, gõ vào dxdiag, bấm
OK để gọi ra công cụ DirectX Diagnostic Tool. Ngay trong thẻ đầu tiên (System) bạn sẽ
đọc được phiên bản của DirectX đang sử dụng. Các thẻ còn lại: DirectX Files, Display,
Sound, Music, Input, Network. Sẽ cung cấp cho bạn các thành phần của DirectX, các
Driver đã cài đặt vào hệ thống, thử các chức năng Multimedia và chẩn đoán các sự cố
xảy ra. Thường thì khi không có vấn đề gì gây lỗi khung Notes sẽ có dòng thông báo No
problems found. Nếu có sự cố gì bạn nên bấm chọn thẻ More Help để nhận được sự trợ
giúp.
Card AGP (tăng tốc đồ họa) tương thích DirectX.
+ Các loại NVIDIA thuộc thế hệ Riva, TNT, TNT2, Quadro trở về trước tuơng thích tốt với
DirectX 8.0
+ Các loại Soltek Geforce Ti trở lên thì dùng rất tốt với DirectX 9.0
Vì vậy, khi cài đặt nâng cấp DirectX bạn phải cẩn thận. Ví dụ tôi dùng Card AGP hiệu
NVDIA RIVA TNT2 Model 64. Xài phiên bản DirectX 8.0 và 8.1 thì nhận đúng 32MB.
Nhưng với Direct 6.1 nó chỉ nhận được 1MB. Còn với Direct 9.0 thì chỉ nhận 15MB mà
thôi. Chưa chắc mới đã hơn cũ.

Chương trình đầu tiên
Xây dựng một dự án mới.
12


Bước đầu tiên bạn cần làm cho bất kỳ một ứng dụng nào là tạo một project mới trong Visual
Studio. Bạn hãy chạy Visual Studio .Net với chế độ không mở bất kỳ một project nào.
1. Lựa chọn New, Project từ thực đơn File, hộp thoại New Project sẽ xuất hiện có dạng
tương tự hình minh hoạ 2.1 dưới đây.

2. Thay đổi tên của project thành example1 và lựa chọn loại ứng dụng là Win32 Project từ

danh sách các project mẫu (project templates). Kích chọn nút OK để hoàn tất, một hộp thoại
có tên Application Wizard sẽ xuất hiện với 2 tabs cho bạn lựa chọn và xác lập là:
Overview, Application Settings. (hình minh hoạ 2.2)

3. Lựa chọn Application Settings tab và chắc chắn rằng lựa chọn Empty Project (tạo một dự
án rỗng) đã được tích chọn, hình minh hoạ 2.3.

13


4. Kích chọn nút Finish để kết thúc.
Chèn thêm mã lệnh cho chương trình
Sau khi bạn thực hiện các bước trên, Visual Studio đã tạo ra một project mới cho bạn tuy
nhiên nó vẫn chưa chứa bất kỳ thứ gì cả. Bước tiếp theo, chúng ta sẽ tiến hành thêm mã
lệnh để khởi tạo cho một ứng dụng trong môi trường window. Bạn hãy bắt đầu bằng cách
chèn thêm một tệp tin mới chứa mã nguồn và dự án.
1. Lựa chọn Add New Item từ thực đơn Project. Một hộp thoại tương tự hình minh hoạ
2.4 phía dưới đây sẽ xuất hiện.
2. Lựa chọn kiểu file C++ File (.cpp) từ danh sách kiểu tệp tin mẫu (Templates).
3. Thay đổi tên tệp tin thành winmain.cpp

4. Kích chuột vào nút Open để mở tệp tin đó và bắt đầu viết mã lệnh.

14


WinMain
Phần đầu tiên của bất kỳ một ứng dụng nào bao giờ cũng là Entry point (điểm bắt đầu, khởi
tạo). Trong các ứng dụng được viết dưới dạng Consolo, hàm bắt đầu có tên là main(), trong
khi đó hàm bắt đầu của một ứng dụng Window bao giờ cũng là WinMain(). Hàm WinMain

này được dùng để khởi tạo ứng dụng của bạn như tạo cửa sổ giao diện chương trình, thiết
lập hàm quản lý sự kiện. Tại tời điểm này bạn có thể gõ lại theo đoạn code được liệt kê dưới
đây hoặc mở file winmain.cpp trong thư mục chapter2\example1.
// khai báo sử dụng thư viện mẫu của Windows - cần thiết cho tất cả các ứng dụng
#include <windows.h>
HINSTANCE hInst; // khai báo biến toàn cục chứa con trỏ instance (biến thể) của chương
trình
HWND wndHandle; // biến toàn cục chứa con trỏ quản lý cửa sổ ứng dụng
// khai báo hàm
bool initWindow( HINSTANCE hInstance );
LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );
// Đây là hàm winmain, hàm được gọi đầu tiền của mọi ứng dụng trong window
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpCmdLine, int nCmdShow )
{
// khởi tạo cửa sổ ứng dụng
if ( !initWindow( hInstance ) )
return false;
// vòng lặp chính dùng để quản lý thông điệp:
MSG msg;
ZeroMemory( &msg, sizeof( msg ) );
while( msg.message!=WM_QUIT )
{
// Kiểm tra các sự kiện được gửi tới trong hàng đợi của ứng dụng
while (GetMessage(&msg, wndHandle, 0, 0) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}

return (int) msg.wParam;
}
Phần quan trọng nhất của hàm trên là phần quản lý các thông điệp của chương trình. Phần
này đảm nhiệm quá trình quản lý các thông điệp mà window gửi tới ứng dụng. Hàm
GetMessage làm nhiệm vụ kiểm tra các thông điệp trong hàng đợi của chương trình, nhận
dạng những thông điệp mà người dùng gửi tới và đang chờ chương trình xử lý. Khi có bất kỳ
một thông điệp nào được gửi tới (hàm GetMessage() trả về giá trị True) thì hàm
TranslateMessage and DispatchMessage sẽ được gọi để xử lý.
Sau khi bạn đã tạo xong hàm WinMain, bây giờ là lúc chúng ta xây dựng hàm tạo cửa sổ ứng
dụng.
15


InitWindow
Trong môi trường Window, bất kỳ một ứng dụng nào muốn tạo một cửa sổ trên màn hình
desktop đều cần phải đăng ký 1 lớp đối tượng thuộc lớp window. Sau khi lớp đó được đăng
ký ứng dụng của bạn sẽ có thể tạo những cửa sổ cần thiết. Đoạn mã dưới đây là một ví dụ
quá trình đăng kí một cửa sổ thông thường với hệ thống và sau đó lớp này sẽ được dùng để
tạo ra một cửa sổ thực sự trong môi trường Windows.
/
***************************************************************************
***
* bool initWindow( HINSTANCE hInstance )
* initWindow registers the window class for the application, creates the window
***************************************************************************
***/
bool initWindow( HINSTANCE hInstance )
{
WNDCLASSEX wcex;
// Xác lập thuộc tính đối tượng kiểu WNDCLASSEX structure. Các thuộc tính này sẽ tác

// động tới cách thể hiện của cửa sổ chương trình
wcex.cbSize = sizeof(WNDCLASSEX); // hàm sizeof() trả về kích thước của một đối
//tượng kiểu dữ liệu đầu vào – đơn vị tính là byte
wcex.style = CS_HREDRAW | CS_VREDRAW; // xác lập kiểu lớp
wcex.lpfnWndProc = (WNDPROC)WndProc; // xác lập tên hàm gọi lại callback procedure
wcex.cbClsExtra = 0; // xác lập số byte cấp phát thêm cho Class
wcex.cbWndExtra = 0; // xác lập số byte cấp phát thêm cho mỗi instance của Class
wcex.hInstance = hInstance; // con trỏ (handle) trỏ tới instance của ứng dụng
wcex.hIcon = 0; //loại biểu tượng chương trình
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);// xác lập kiểu con trỏ chuột mặc định
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); // màu nền của cửa sổ
wcex.lpszMenuName . = NULL; // con trỏ trỏ tới object dữ liệu thực đơn ứng dụng
wcex.lpszClassName = “DirectXExample”; // tên lớp đăng ký với hệ thống
wcex.hIconSm = 0; // con trỏ tới dữ liệu biểu tượng cửa sổ ứng dụng
RegisterClassEx(&wcex); //gọi hàm đăng ký lớp với hệ thống
// Tạo cửa sổ mới
wndHandle = CreateWindow(
“DirectXExample”, //tên lớp sử dụng đã khai báo và đăng ký ở trên
“DirectXExample”, //tiêu đề của cửa sổ chương trình
WS_OVERLAPPEDWINDOW, //loại của sổ chương trình
CW_USEDEFAULT, // toạ độ X của của sổ khi xuất hiện
CW_USEDEFAULT, // toạ độ Y của của sổ khi xuất hiện
640, // kích thước bề ngang của cửa sổ - đơn vị là pixel
480, // kích thước chiều cao của cửa sổ
NULL, // con trỏ trỏ tới đối tượng cha ;
//NULL = đối tượng quản lý là desktop của Windows
NULL, // con trỏ đối tượng menu của chương trình; NULL = không sử dụng
16



hInstance, // con trỏ instance của ứng dụng
NULL); // không có giá trị gì được truyền cho cửa sổ
// Kiểm tra lại xem quá trinh khởi tạo cửa sổ có thành công hay không
if (!wndHandle)
return false;
// Thể hiện cửa sổ lên màn hình Window
ShowWindow(wndHandle, SW_SHOW);
UpdateWindow(wndHandle);
return true;
}
Tất cả thông tin, ý nghĩa của các hàm sử dụng ở trên bạn có thể tham khảo thêm trong bất
kỳ tài liệu hướng dẫn lập trình windows nào. Chính vì thế chúng ta sẽ đi nhanh qua các phần
này, các mã lệnh sẽ được được viết một số chú thích để bạn dễ hình dung hơn tiến trình
thực hiện của chương trình.
Tất cả các ứng dụng muốn thể hiện một cửa sổ trên màn hình đều phải thực hiện quá trinh
đăng ký lớp cửa sổ đó với hệ thống. Lớp cửa sổ này chứa những đặc tính của cửa sổ như
màu màn hình nền, loại biểu tượng chuột sử dụng, và biểu tượng thể hiện của chương trình.
Lớp cửa sổ này đã được cung cấp mâu khai báo sẵn theo cấu chúc đối tượng WNDCLASSEX.
Sau khi đối tượng có kiểu WNDCLASSEX đã được xác lập đầy đủ các thông tin, nó sẽ được
truyền làm tham số cho lời gọi hàm đăng ký với hệ thống RegisterClassEx.
Hàm RegisterClassEx sẽ lấy thông tin được cung cấp trong đối tượng WNDCLASSEX truyền
cho hàm và thực hiện quá trình đăng ký lớp cửa sổ ứng dụng với hệ thống. Sau khi bạn đã có
một lớp cửa sổ được đăng ký, bạn sẽ có thể tạo ra các cửa sổ được sử dụng trong ứng dụng.
Bước tiếp theo đó là tạo ra cửa sổ, nó được thực hiện thông qua hàm CreateWindow. Hàm
CreateWindow này yêu cầu 11 đối số, mỗi một thông số được cung cấp sẽ được chú giải
trong phần mã nguồn ở trên.
WndProc
Hàm WndProc (Window Procedure) là một hàm nữa bạn cần phải khai báo cho một cửa sổ
ứng dụng. Mã nguồn của hàm này được minh hoạ ở dưới đây, hàm này sẽ làm nhiệm vụ
đón nhận những sự kiện mà hệ thống gửi đến cho ứng dụng. Ví dụ như, khi sự kiện chuột

được kích trên cửa sổ ứng dụng, hệ thống sẽ gửi sự kiện kích chuột này tới cho ứng dụng
thông qua hàm WndProc này. Trong hàm này, bạn sẽ tiến hành khai báo sự những sự kiện
nào sẽ được xử lý hay bỏ qua chúng. Đoạn mã ví dụ dưới đây sẽ minh hoạ những sự kiện
đơn giản nhất mà một ứng dụng cần quản lý.
/**************************************************************************
****
* LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam,
* LPARAM lParam)
* The window procedure
***************************************************************************
***/
LRESULT CALLBACK WndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
17


// Kiểm tra xem có thông điệp nào được gửi tới hàng đợi cửa ứng dụng không
switch (message) //lọc các thông điệp
{
case WM_DESTROY: //bắt thông điệp yêu cầu kết thúc ứng dụng
PostQuitMessage(0); //gọi hàm xử lý
break;
}
// Chú ý, hàm này yêu cầu bạn phải cung cấp thông điệp trả về cho quá trình
// xứ lý tiếp theo
return DefWindowProc(hWnd, message, wParam, lParam);
}
Tại thời điểm này, bạn đã có thể biên dịch ứng dụng và chạy thử, sau khi chạy, ứng dụng sẽ
có dạng một cửa sổ có nền trắng tương tự hình minh hoạ dưới đây. Bạn cũng có thể tìm

thấy chương trình này trong thư viện Chapter2\example1

Sử dụng DirectX
Với phiên bản DirectX 8 trước đây, phần vẽ các đối tượng được chia ra làm hai hệ thống
giao diện: DirectDraw và Direct3D. DirectDraw được sử dụng để thể hiện các đối tượng 2D,
nó không còn được tiếp tục phát triển thêm nữa. Chính vì thế với phiên bản D9, nó đã được
gộp lại toàn bộ trong một giao diện thống nhất thông qua các hàm API của Direct3D. Trong
phần này chúng ta sẽ dần dần tiếp cận với cách để thực hiện tất cả quá trình vẽ thông qua
Direct3D. Trước tiên là các bước sác lập hệ thống để có thể chạy được hệ
thống giao diện lập trình Direct3D và tiếp đến là thực thi nó:
- Tạo một đối tượng Direct3D.
- Tạo một môi trường Direct3D (thiết bị - device) để thể hiện đối tượng.
- Vẽ các đối tượng lên môi trường đó.
Đối tượng Direct3D
Đối tượng Direct3D là một đối tượng cung cấp một giao diện được sử dụng bởi các hàm để
18


tập hợp và nhận biết khả năng tương thích của môi trường Direct3D. Có thể ví dụ, một đối
tượng Direct3D đem đến cho bạn khả năng tìm và xác nhận xem hệ thống có bao nhiêu thiết
bị hiển thị đồ hoạ đã được cài đặt trên hệ thống cũng như kiểm tra khả năng tương thích
(hỗ trợ) của chúng.
Một đối tượng Direct3D được tạo thông qua cách sau:
IDirect3D9 *Direct3DCreate9( D3D_SDK_VERSION );
Chú ý:
D3D_SDK_VERSION chỉ là một tham số mặc định có thể gửi cho hàm Direct3DCreate9

Hàm này sẽ trả về một con trỏ trỏ tới giao diện IDirect3D9. Giá trị trả về của hàm sẽ là NULL
nếu quá trình tạo mới một đối tượng thất bại. Bạn có nhớ là tôi đã đề cập tới khả năng truy
suất số lượng thiết bị hiển thị video hay adapters trên máy? Đây là một chức năng đã được

cung cấp trong Direct3D, để làm được điều này bạn chỉ cần làm những việc sau.
UNIT IDirect3D9::GetAdapterCount(VOID);
Hàm GetAdapterCound có khả năng cho phép bạn biết số lượng thiết bị hiển thị của hệ
thống. Hàm này không yêu cầu bất kỳ một tham số nào phải truyền cho nó và thông thường
nó sẽ có giá trị trả về là 1.
Tạo một thiết bị kết xuất (Rendering)

Một Direct3D device, thông qua giao diện IDirect3DDevice9 sẽ cung cấp các phương thức
cho các ứng dụng có thể sử dụng để kết xuất hình ảnh ra màn hình. Thông qua giao diện này
tất cả các thao tác vẽ trong game của bạn sẽ được thực hiện. Một thiết bị Direct3D này có
thể được tạo bằng cách gọi tới hàm CreateDevice.
HRESULT CreateDevice(
UINT Adapter,
D3DDEVTYPE DeviceType,
HWND hFocusWindow,
DWORD BehaviorFlags,
D3DPRESENT_PARAMETERS *pPresentationParameters,
IDirect3DDevice9** ppReturnedDeviceInterface
);
Đối tượng thiết bị kết quả trả về này sẽ được sử dụng trong toàn bộ game của bạn để truy
cập và kết xuất kết quả vẽ tới các thiết bị hiển thị phần cứng. Hàm CreateDevice này yêu cầu
6 tham số đầu vao và trả về một kết quả kiểu HRESULT. Nếu như quá trình thực hiện hàm
này thanh công, kết quả trả về sẽ là D3D_OK; trong các trường hợp khác nó có thể là một
trong các giá trị dưới đây:
ƒ D3DERR_INVALIDCALL. Một trong những tham số cung cấp cho hàm không hợp lệ.
ƒ D3DERR_NOTAVAILABLE. Thiết bị không hỗ trợ bạn gọi hàm này.
ƒ D3DERR_OUTOFVIDEOMEMORY. Card đồ hoạ không đủ bộ nhớ để thực hiện hàm lời
gọi hàm này.
19



Các tham số cần thiết của hàm CreateDevice:
ƒ Adapter. Có kiểu UINT. Có giá trị là số hiệu của card đồ hoạ mà thiết bị dùng để
hiển thị. Hầu hết các ứng dụng game sẽ gửi giá trị D3APAPTER_DEFAULT cho
hàm để mặc định sử dụng thiết bị đồ hoạ chính của hệ thống.
Chú ý:
Nếu hệ thống chỉ có một thiết bị hiển thị được cài đặt (card đồ hoạ), thì thiết bị đó sẽ được
coi là thiết bị chính để hiển thị. Trong trường hợp có nhiều hơn 1 thì thiết bị đầu tiên sẽ là
thiết bị chính.
Chú ý:
Một thói quen tốt mà bạn nên tạo lập đó là luôn luôn kiểm tra kết quả trả về của hàm để
đảm bảo chắc chắn quá trình tạo đối tượng đã thực hiện chính xác mặc dù hầu hết các
trường hợp hàm này sẽ trả về kết quả D3D_OK.

ƒ DeviceType. Có kiểu D3DDEVTYPE. Có 3 kiểu thiết bị mà bạn có thể lựa chọn
để khởi tạo:
• D3DDEVTYPE_HAL. Thiết bị sử dụng chức năng hỗ trợ từ phần cứng card
đồ hoạ tốc độ cao.
• D3DDEVTYPE_REF. Các tính năng của Direct3D sẽ được cài đặt trong
phần mềm, tuy nhiên sẽ sử dụng các chức năng đặc biệt mà CPU hỗ trợ nếu
có thể.
• D3DDEVTYPE_SW. Thiết bị cắm-chạy có chức mô phỏng bằng phần mềm
sẽ được sử dụng.
ƒ hFocusWindow. Có kiểu HWND. Đây là con trỏ của cửa sổ sử dụng thiết bị đó.
ƒ BehaviorFlags. Có kiểu DWORD. Tham số này cho phép xác lập nhiều giá trị cờ
trạng thái khác nhau cho quá trình khởi tạo thiết bị. Trong ví dụ minh hoạ ở đây
chúng ta chỉ sử dụng giá trị cờ trạng thái xác lập tiến trình sử lý vertex sẽ được
thực hiện bằng phần mềm: D3DCREATE_SOFTWARE_VERTEXPROCESSING.
ƒ PresentationParamters. Có kiểu D3DPRESENT_PARMETERS. Đây là tham số
điều khiển quá trình hiển thị của thiết bị như xác lập kiểu hiển thị cửa sổ ứng

dụng/fullcreen hay có sử dụng hay không bộ nhớ đêm backbuffer. Cấu trúc của
tham số này có dạng sau:

typedef struct _D3DPRESENT_PARAMETERS_ {
UINT BackBufferWidth, BackBufferHeight;
D3DFORMAT BackBufferFormat;
UINT BackBufferCount;
D3DMULTISAMPLE_TYPE MultiSampleType;
DWORD MultiSampleQuality;
D3DSWAPEFFECT SwapEffect;
HWND hDeviceWindow;
BOOL Windowed;
BOOL EnableAutoDepthStencil;
20


D3DFORMAT AutoDepthStencilFormat;
DWORD Flags;
UINT FullScreen_RefreshRateInHz;
UINT PresentationInterval;
}
D3DPRESENT_PARAMETERS;
Bảng 2.1 sẽ mô tả chi tiết hơn các tham số trên
ppReturnedDeviceInterface. Có kiểu IDirect3Ddevice9**. Đây là biến chứa con
trỏ thiết bị được tạo hàm tạo ra nếu quá trình khởi tạo thành công. Sau khi một thiết bị hiển
thị đã được khởi tạo bạn sẽ có thể gọi tiếp các phương thức khác của Direct3D để lấy hoặc
vẽ bất kỳ một đối tượng nào lên màn hình.

Xoá màn hình


Sau khi một thiết bị Direct3D đã được tạo ra, bây giờ bạn có thể bắt đầu tô điểm lên màn
21


hình, bạn có thể làm điều này với các bức ảnh hay thông qua một số đa giác. Tuy nhiên công
việc đầu tiên bạn phải làm trong vòng lặp chính của ứng dụng game là xoá sạch màn hình.
Việc xoá màn hình này sẽ cho bạn một khung hình hoàn toàn mới để thao tác và vẽ các đối
tượng lên đó. Tệp tin winmain.cpp đã được cập nhật thêm hàm này bạn có thể tìm thấy
trong thư mục chapter2\example2 trên CD-ROM. Bạn có thể xoá toàn bộ màn hình bằng
cách gọi tới hàm Clear.
HRESULT Clear(
DWORD Count,
const D3DRECT *pRects,
DWORD Flags,
D3DCOLOR Color,
float Z,
DWORD Stencil
);
Bạn phải truyền đầy đủ 6 tham số cần thiết cho hàm.
Tham số thứ nhất, Count – số lượng vùng hình chữ nhật được xoá. Nếu tham số này là 0 thì
tham số thứ 2 pRects phải là giá trị NULL. Trong trường hợp đó, toàn bộ vùng nhiên của màn
hình sẽ được xoá, đây là các tham số hay được sử dụng nhất. Nếu giá trị Count lớn hơn 0,
pRects phải trỏ tới mảng các đối tượng kiểu D3DRECT lưu giữ toạ độ các vùng chữ nhật
được xoá. Tham số cờ trạng thái Flags xác lập bộ đệm sẽ được xoá. Có 3 trường hợp:
ƒ D3DCLEAR_STENCIL
ƒ D3DCLEAR_TARGET
ƒ D3DCLEAR_ZBUFFER
Giá trị mà bạn sẽ sử dụng tại thời điểm này là D3DCLEAR_TARGET, nó dùng đề xác lập đối
tượng được xoá là vùng dữ liệu hiển thị hiện thời. Color – giá trị màu (có kiểu D3DCOLOR) sẽ
được xác lập sau khi xoá. Có rất nhiều marcos sẽ trợ giúp bạn xác lập giá trị màu theo ý

muốn tuỳ theo các chuẩn màu sắc khác
nhau, ví dụ như D3DCOLOR_XRGB. Tham số Z xác lập giá trị chiều sâu bộ đệm. Giá trị này
nằm trong khoảng từ 0.0f tới 1.0f.
Chúng ta sẽ nói sâu hơn về nó trong các chương sau.
Tham số Stencil lưu giá trị số hiệu bộ đệm mẫu tô. Nếu bạn không sử dụng bộ đệm này thì
bạn phải truyền giá trị này cho hàm là 0.
Thể hiện một phông cảnh
Sau khi bạn đã xoá sạch một khung hình, bây giờ là lúc chúng ta thể hiện nó lên màn hình.
Direct3D sử dụng hàm Present để làm điều này. Hàm Present này sẽ thực hiện việc chuyển
đổi trang của bộ đệm nền. (có thể ví quá trình hiển thị hình ảnh như việc lật những bức vẽ
(từ bộ đệm) lên màn hình).
Thực chất thì tất cả quá trình bạn thao tác vẽ cho tới thời điểm này đều được thực hiện trên
bộ nhớ đệm. Bộ nhớ đệm back buffer này là một vùng nhớ để lưu giữ toàn bộ kết quả vẽ
trước khi nó được kết xuất lên màn hình. Page flipping (lật trang) là một tiến trình lấy các
thông tin từ bộ nhớ đệm và hiển thị nó lên màn hình. Việc làm này nhằm giảm hiện tượng
giật hình do tốc độ hiển thị của màn hình thường chậm hơn nhiều so với tốc độ sử lý của bộ

22


nhớ trên card màn hình. Hàm này sẽ đảm bảo quá trình hiển thị sẽ mượt mà hơn
và tất cả những gì bạn thực hiện trên bộ nhớ đệm sẽ được hiển thị lên màn hình. (!)
Cấu trúc của hàm Present:
HRESULT Present(
CONST RECT *pSourceRect,
CONST RECT *pDestRect,
HWND hDestWindowOverride,
CONST RGNDATA *pDirtyRegion
);
Chú ý:

Lật trang là quá trình tráo đổi dữ liệu từ bộ nhớ đệm lên bộ nhớ thực của màn hình, để
thực hiện quá trình hiển thị thì bạn phải gọi tới hàm yêu cầu lật trang này mỗi khi thực hiện
xong các thao tác vẽ trên bộ nhớ đệm.
Hàm Present này yêu cầu 4 tham số đầu vào:
ƒ pSourceRect là một con trỏ có kiểu RECT trỏ tới dữ liệu vùng chữ nhật thể hiện từ bộ nhớ
đệm backbuffer. Giá trị này phải được gán là NULL nếu bạn muốn sử dụng toàn bộ dữ liệu
vùng nhớ đệm backbuffer – đây cũng là trường hợp thường dùng.
ƒ pDesRect là một con trỏ kiểu RECT khác chứa địa chỉ vùng chữ nhật đích.
ƒ hDestWindowOverride là con trỏ trỏ tới của sổ đích được dùng để hiển thị. Giá trị này
phải được xác lập là NULL nếu bạn sử dụng những xác lập cửa sổ trước đó trong phần khai
báo tham số hiển thị ở trên.
ƒ pDirtyRegion là con trỏ trỏ tới những vùng mà bộ đệm cần được cập nhật dữ liệu. Một
lần nữa giá trị này là NULL nếu bạn muốn cập nhật toàn bộ dữ liệu bộ đệm.
Dọn dẹp bộ nhớ (Cleaning Up)
Công việc cuối bạn phải làm trong bất kỳ một ứng dụng DirectX nào là dọn dẹp vào giải
phóng bộ nhớ cho các đối tượng bạn đã sử dụng. Ví dụ như, tại thời điểm bắt đầu của ứng
dụng, bạo đã tạo ra cả một đối tượng Direct3D cũng như một thiết bị Direct3D. Khi ứng
dụng được đóng lại, bạn cần thiết phải giải phóng những đối tượng đó để trả lại tài nguyên
các đối tượng đó đã chiếm chỗ cho hệ thống thực hiện các công việc khác.
Các đối tượng COM, nền tảng của DirectX, luôn được quản lý bởi hệ thống thông qua một
biến đếm lưu giữ số lượng đối tượng mà ứng dụng đã tạo ra cũng như còn lại sau khi vừa
được loại bỏ. Bằng việc sử dụng hàm Release, bạn vừa thực hiện việc giải phóng đối tượng
và vừa tác động tới biến đếm (count) đó. Khi mà biến đếm đạt giá trị 0, hệ thống sẽ giải
phóng toàn bộ bộ nhớ mà các đối tượng đã sử dụng.
Lấy vị dụ, khi giải phóng một thiết bị hiển thị Direct3D, bạn sử dụng lệnh sau:
If ( pd3dDevice != NULL )
pd3dDevice->Release( );
Nếu điều kiện trong câu lệnh If được thoả mãn (tức là biến pd3dDevice có chứa dữ liệu – nó
được gán cho địa chỉ của một thiết bị được khởi tạo trước đó), thì thực hiện quá trình giải
phóng biến đó.

23


Cập nhật mã nguồn chương trình.
Sau khi đã tìm hiểu qua một vài lệnh và thông tin cơ bản về DirectX, bây giờ là lúc bạn sẽ
xem xét làm thế nào để xác lập và chạy một ứng dụng DirectX, là lúc để chúng ta thêm các
mã lệnh mới vào ứng dụng. Những mã lệnh này sẽ được chèn thêm vào trong tệp tin
winmain.cpp mà chúng ta đã tạo trong phần trước.
Bước đầu tiên trước khi viết bất kỳ một ứng dụng DirectX nào đó là chèn tệp tin header của
Direct3D. Bạn thực hiện khai báo như sau trong ứng dụng:
#include <d3d9.h>
Tiếp theo bạn cần khai báo 2 biến toàn cục sẽ cần thiết trong quá trình lưu giữ con trò đối
tượng để toàn bộ ứng dụng sử dụng.
Chú ý:
Bạn nên kiểm tra xem chắc chắn một đối tượng DirectX có khác rỗng (NULL) không trước
khi gọi hàm Release đối với nó. Nếu bạn gọi hàm này trên một đối tượng rỗng thì chắc
chắn sẽ xảy ra lỗi cho ứng dụng.
25
LPDIRECT3D9 pD3D; //Đối tượng Direct3D
LPDIRECT3DDEVICE9 pd3dDevice; //thiết bị hiển thị Direct3D
Biến được khai báo kiểu LPDIRECT3D9 là một con trỏ sử dụng giao diện IDirect3D9, tương tự
biến LPDIRECT3DDEVICE9 là con trỏ sử dụng giao diện IDirect3DDevice9. Tiếp theo, bạn sẽ
cần phải gọi tới hàm initDirrect3D, bạn có thể thực hiện theo cách tôi sử dụng dưới đây. Chú
ý là bạn phải đặt đoạn code gọi tới hàm này sau khi đã gọi hàm
initWindow ở trong hàm WinMain.
// hàm này được gọi sau khi quá trình khởi tạo cửa sổ ứng dụng kết thúc
If ( !initDirect3D( ) )
return false;
Thay đổi mã lệnh trong vòng lặp quản lý sự kiện


Sau khi đã xác lập các thông số khởi tạo, bây giờ là lúc chúng ta thay thế vòng lặp quản lý sự
kiện Windows bằng một mã lệnh khác hữu dụng hơn cho các ứng dụng game. Trong vòng
lặp quản lý sự kiện ban đầu chúng ta sử dụng thì vòng lặp này sẽ liên tục gọi tới hàm
GetMessage để kiểm tra sự kiện mỗi khi nó được gửi tới và chờ ứng dụng sử lý; Nếu thông
điệp được gửi tới, hàm GetMassage sẽ phải đợi tới khi thông điệp sử lý xong mới tiếp tục.
Chính vì thế trong phần này thay vì sử dụng hàm GetMassage thì chúng ta
sẽ sử dụng hàm PeekMessage, hàm này cũng có chức năng kiểm tra thông điệp tuy nhiên nó
trả điều khiển về ngay lập tức, cho phép ứng dụng game của bạn có thể gọi lại chinh nó
trong vòng lặp. Trong ví dụ này, chúng ta sẽ chèn thêm mệnh đề else sau lời gọi
PeekMessage để gọi tới hàm render của game. Hàm render này sẽ thực hiện quá trình vẽ
các đối tượng lên màn
hình, hàm này sẽ được định nghĩa ngay ở phần sau.
if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage ( &msg );
DispatchMessage ( &msg );
}
else
24


{
render( );
}
Hàm khởi tạo Direct3D
Trong hàm initDirect3D này chúng ta sẽ thực hiện việc tạo một đối tượng Direct3D và thiết
bị để sử dụng chúng.
/*********************************************************************
* initDirect3D
*********************************************************************/

bool initDirect3D(void)
{
pD3D = NULL;
pd3dDevice = NULL;
// Create the DirectX object
if( NULL == ( pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
{
return false;
}
// Fill the presentation parameters structure
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.BackBufferCount = 1;
d3dpp.BackBufferHeight = 480;
d3dpp.BackBufferWidth = 640;
d3dpp.hDeviceWindow = wndHandle;
// Create a default DirectX device
if( FAILED( pD3D->CreateDevice( D3DADAPTER_DEFAULT,
D3DDEVTYPE_REF,
wndHandle,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp,
&pd3dDevice ) ) )
{
return false;
}
return true;

}
Tại đoạn đầu của hàm trên, chúng ta đã tạo một lời gọi tới hàm Direct3DCreate9. Nó sẽ thực
hiện lệnh tạo một đối tượng Direct3D, từ đó bạn có thể tạo một thiết bị hiển thị Direct3D.
Tiếp đến là quá trinh xác lập các thông số hiển thị của ứng dụng. Chúng ta đã xác lập một
cửa số có kích thước 640 x 480. Tiếp theo là hàm CreateDevice sẽ được gọi với tham số thứ
2 ở cuối cùng là biến cấu trúc với dữ liệu đã vừa được định nghĩa. Cũng tại đây chúng ta
25