LUẬN VĂN:XÂY DỰNG GAME ENGINE ĐA NỀN TẢNG HIỆU ỨNG ÁNH SÁNG VÀ VẬT LIỆU

ĐẠI HỌC QUỐC GIA HÀ NỘI TRƯỜNG ĐẠI HỌC CÔNG NGHỆ

Bùi Hoàng Khánh

XÂY DỰNG GAME ENGINE ĐA NỀN TẢNG -

HIỆU ỨNG ÁNH SÁNG VÀ VẬT LIỆU

KHOÁ LUẬN TỐT NGHIỆP ĐẠI HỌC HỆ CHÍNH QUY

HÀ NỘI – 2009

Ngành: Công nghệ thông tin

ĐẠI HỌC QUỐC GIA HÀ NỘI

TRƯỜNG ĐẠI HỌC CÔNG NGHỆ

Bùi Hoàng Khánh

XÂY DỰNG GAME ENGINE ĐA NỀN TẢNG -

HIỆU ỨNG ÁNH SÁNG VÀ VẬT LIỆU

KHOÁ LUẬN TỐT NGHIỆP ĐẠI HỌC HỆ CHÍNH QUY

Ngành: Công nghệ thông tin

Cán bộ hướng dẫn: ThS. Vũ Quang Dũng

HÀ NỘI – 2009

LỜI CẢM ƠN

Lời đầu tiên tôi xin bày tỏ lòng biết ơn chân thành tới các thầy cô giáo Trường

Đại học Công Nghệ, Đại học Quốc Gia nói chung và các thầy cô bộ môn công nghệ

Phần mềm nói riêng. Trong suốt thời gian tôi học tại trường, các thầy cô đã luôn tận

tình dạy dỗ, chỉ bảo để tôi có được kết quả như ngày hôm nay.

Đặc biệt, tôi xin chân thành cảm ơn giảng viên, thạc sĩ Vũ Quang Dũng. Cảm ơn

thầy vì những định hướng, nhận xét quý báu và động viên kịp thời của thầy đã giúp tôi

hoàn thành khóa luận này. Tôi cũng xin cảm ơn phòng thí nghiệm Toshiba – Coltech

đã tạo điều kiện cho tôi có môi trường làm việc trong quá trình thực hiện khóa luận

này.

Cuối cùng tôi xin bày tỏ lòng biết ơn sâu sắc tới gia đình và bạn bè, những người đã luôn động viên, giúp đỡ tôi cả về vật chất lẫn tinh thần trong suốt những năm tháng qua.

Hà Nội, ngày 19 tháng 05 năm 2009

Sinh viên

Bùi Hoàng Khánh

TÓM TẮT

Sự phát triển của công nghệ mô phỏng và giải trí, ngày càng có nhiều ứng dụng

đồ họa và trò chơi 3D được xây dựng nhằm phục vụ mục đích nghiên cứu, mô phỏng

và giải trí… Cùng với đó, công nghệ phần cứng cũng phát triển rất nhanh, đặc biệt là

các phần cứng xử lý đồ họa có thể lập trình được và các ngôn ngữ lập trình trên các

phần cứng này. Tuy nhiên, để xây dựng một ứng dụng đồ họa và trò chơi 3D đảm bảo

các yêu cầu: hỗ trợ một dải phần cứng và phần mềm (cụ thể là hệ điều hành) lớn, có

khả năng lựa chọn API đồ họa mức thấp (OpenGL, OpenGL ES hay DirectX), dễ d àng

quản lý và phát triển các tài nguyên; các ứng dụng này được xây dựng từ một game

engine, chứ không phát triển từ nguyên thủy.

Xuất phát từ thực tế đó, khóa luận tập trung nghiên cứu xây dựng một hệ thống Game Engine hỗ trợ xây dựng ứng dụng đồ họa và trò chơi 3D trên nhiều nền tảng khác nhau. Hệ thống Game Engine được xây dựng sẽ cung cấp giao diện lập trình ở mức cao. Khi phát triển các ứng dụng đồ họa 3D, người lập trình không cần phải quan tâm đến quá trình quản lý tài nguyên, cũng như xử lý đồ họa ở mức thấp bên dưới. Thay vào đó, họ chỉ cần tập trung vào quản lý ở mức lôgíc các thành phần của ứng dụng, hoặc thêm mới các thành phần dựa trên thành phần cơ sở do hệ thống cung cấp.

Nội dung của khóa luận này tập trung nghiên cứu các vấn đề sau:

- Môi trường phát triển hệ thống Game Engine ứng dụng đồ họa và trò chơi 3D, gồm nền tảng phần cứng, phần mềm, và các công nghệ đồ họa ở mức thấp (như

OpenGL, OpenGL ES, DirectX).

- Thiết kế và xây dựng một hệ thống đồ họa có cấu trúc và tương tác với người

dùng.

- Nghiên cứu và triển khai các kỹ thuật tạo hiệu ứng về ánh sáng trong khung

cảnh 3D.

MỤC LỤC

LỜI CẢM ƠN ............................................................................................... i

TÓM TẮT .................................................................................................... ii

MỤC LỤC ................................................................................................... iii

BẢNG CÁC TỪ VIẾT TẮT ....................................................................... v

DANH MỤC HÌNH VẼ ............................................................................. vi

DANH MỤC BẢNG BIỂU ...................................................................... viii

MỞ ĐẦU ...................................................................................................... 1

Chương 1: TỔNG QUAN VỀ GEM .......................................................... 3

1.1. Khái niệm Game Engine ........................................................................... 3

Chương 2: CƠ SỞ LÝ THUYẾT............................................................... 9

1.2. Mô hình của GEM ..................................................................................... 3 1.2.1. Các đặc điểm của GEM ........................................................................ 3 1.2.2. Kiến trúc tổng thể ................................................................................. 4 1.2.2.1. Thành phần Cấu trúc dữ liệu cơ bản .............................................. 5 1.2.2.2. Thành phần Giao tiếp với Hệ điều hành ........................................ 6 1.2.2.3. Thành phần Render Engine ........................................................... 7 1.2.2.4. Các thành phần còn lại ................................................................... 8

2.1. Ánh sáng trong đồ họa máy tính .............................................................. 9 2.1.1. Các thành phần của ánh sáng ................................................................ 9

2.1.2. Các mô hình tạo bóng ......................................................................... 11

2.2. Đổ bóng ..................................................................................................... 12 2.2.1. Bóng của đối tượng trong khung cảnh ................................................ 12 2.2.2. Phương pháp đổ bóng ......................................................................... 12

2.3. Đối tượng có bề mặt phức tạp ................................................................ 13 2.3.1. Đối tượng với mạng lưới nhiều đa giác .............................................. 13

2.3.2. Kỹ thuật sử dụng bản đồ vector pháp tuyến ....................................... 13 2.3.3. Không gian Texture ............................................................................ 14

iii

Chương 3: MÔ HÌNH ĐỀ XUẤT ............................................................ 16

3.1. Các yêu cầu chung của mô đun .............................................................. 16

Chương 4: THIẾT KẾ CHI TIẾT ........................................................... 19

3.2. Các thành phần trong mô đun ................................................................ 17

4.1. Chiếu sáng ................................................................................................ 19 4.1.1. Vật liệu ................................................................................................ 19

4.1.2. Chiếu sáng bằng mô hình OpenGL cung cấp ..................................... 20

4.1.3. Chiếu sáng bằng mô hình tự định nghĩa ............................................. 22

4.1.3.1. Lớp DLightSceneNode ................................................................ 22

4.1.3.2. Sử dụng DLightSceneNode ......................................................... 25

4.2. Hiệu ứng đổ bóng ..................................................................................... 27

Chương 5: THỰC NGHIỆM ................................................................... 34

4.3. Hiệu ứng Bump ........................................................................................ 30

5.1. Thực nghiệm chương trình ..................................................................... 34 5.1.1. Phương pháp đánh giá ........................................................................ 34 5.1.2. Kết quả đánh giá ................................................................................. 34

KẾT LUẬN ................................................................................................ 37

5.2. Demo chương trình .................................................................................. 35

Kết luận ............................................................................................................ 37

PHỤ LỤC ................................................................................................... 38

TÀI LIỆU THAM KHẢO .......................................................................... a

Hướng phát triển ............................................................................................ 37

BẢNG CÁC TỪ VIẾT TẮT

Ký hiệu Từ tiếng Anh Giải thích

CPU Central processing unit Đơn vị xử lý trung tâm

GPU Graphics processing unit Đơn vị xử lý đồ họa

MMORPG

Massively multiplayer online Trò chơi nhập vai trực tuyến

role-playing game nhiều người chơi

Shading language Ngôn ngữ tạo bóng SL

Shadow volume Vùng giới hạn bóng SV

DANH MỤC HÌNH VẼ

Hình 1: Kiến trúc phân tầng của GEM ................................................................... 3

Hình 2: Kiến trúc tổng thể của GEM ...................................................................... 4

Hình 3: Biểu đồ lớp của thành phần Các kiểu dữ liệu cơ bản ................................ 5

Hình 4: Quá trình điều phối sự kiện ....................................................................... 6

Hình 5: Kiến trúc phân tầng của Render Engine .................................................... 7

Hình 6: Tác động của Ánh sáng trong đồ họa 3D .................................................. 9

Hình 7: Vẽ vật thể với áng sáng Ambient ............................................................ 10

Hình 8: Vẽ vật thể với thành phần Diffuse ........................................................... 10

Hình 9: Vẽ vật thể với thành phần Specular ......................................................... 11

Hình 10: Kết quả của một số mô hình tạo bóng ................................................... 11

Hình 11: Kết quả của cùng một mô hình ánh sáng trên Vertex và Pixel.............. 12

Hình 12: Mô hình của SV ..................................................................................... 13

Hình 13: So sánh giữa sử dụng bản đồ pháp tuyến và thiết kế mô hình .............. 14

Hình 14: Mô hình liên kết với các thành phần khác bên ngoài ............................ 16

Hình 15: Các thành phần của mô đun Hiệu ứng ánh sáng và vật liệu .................. 17

Hình 16: Quá trình Chiếu sáng ............................................................................. 19

Hình 17: Lớp Material .......................................................................................... 20

Hình 18: Lớp LightSceneNode ............................................................................. 20

Hình 19: Sơ đồ “bật” nguồn sáng ......................................................................... 21

Hình 20: Lớp DLightSceneNode .......................................................................... 22

Hình 21: Sơ đô trạng thái “bật” nguồn sáng động ................................................ 23

Hình 22: Lớp DLightEffect .................................................................................. 24

Hình 23: Ví dụ về một lớp sử dụng DLightSceneNode ....................................... 25

Hình 24: Quá trình chiếu sáng bằng hệ thống ánh sáng động .............................. 26

Hình 25: Lớp Shadow ........................................................................................... 27

Hình 26: Sơ đồ trạng thái vẽ bóng ........................................................................ 27

Hình 27: Lớp ShadowEffect ................................................................................. 28

Hình 28: Cấu trúc dữ liệu tính toán Vùng đổ bóng .............................................. 29

Hình 29: Sơ đồ hoạt động của renderShadow() .................................................... 30

Hình 30: Lớp BumpSceneNode ............................................................................ 30

Hình 31: Tính ma trận chuyển từ không gian World sang không gian Texture ... 31

Hình 32: Sơ đồ lớp BumpEffect ........................................................................... 32

Hình 33: Sơ đồ hoạt động của phương thức render() của BumpSceneNode ....... 33

Hình 34: Hình hộp sử dụng hiệu ứng bump ......................................................... 36

Hình 35: Trò chơi cờ vua ...................................................................................... 36

Hình 36: Khung cảnh bên trong một ngôi nhà ..................................................... 36

vii

DANH MỤC BẢNG BIỂU

Bảng 1: Dòng card đồ họa được GEM hỗ trợ ......................................................... 4

Bảng 2: Bảng đánh giá Thực nghiệm 1 ................................................................ 34

Bảng 3: Bảng đánh giá Thực nghiệm 2 ................................................................ 35

Bảng 4: Bảng đánh giá Thực nghiệm 3 ................................................................ 35

viii

MỞ ĐẦU

Với xu hướng phát triển mạnh mẽ của công nghệ phần cứng (cụ thể là các phần

cứng xử lý đồ họa lập trình được và các ngôn ngữ lập trình trên phần cứng này) và

công nghệ mô phỏng và giải trí, các ứng dụng đồ họa và trò chơi 3D được xây dựng và

phát triển ngày càng nhiều. Cách đây 20 năm, các ứng dụng này rất đơn giản và chỉ

cần một người hoặc một nhóm nhỏ người phát triển. Nhưng ngày nay, với tính năng

xử lý đồ họa và tương tác ấn tượng thường được phát triển bởi một đội ngũ đông đảo

gồm nhà thiết kế, lập trình viên… trong khoảng thời gian liên tục từ một đến ba năm.

Để đảm bảo các yêu cầu: hỗ trợ một dải phần cứng và phần mềm (hệ điều hành) lớn,

có khả năng lựa chọn API đồ họa mức thấp (OpenGL, OpenGL ES hay DirectX), dễ

dàng quản lý và phát triển các tài nguyên, và có khả năng tái sử dụng mã nguồn cao; các ứng dụng này thường được phát triển lên từ một game engine thay vì phát triển từ nguyên thủy.

Ở Việt Nam hiện nay, các trò chơi trực tuyến mới chỉ thực sự thâm nhập vào thị trường cách đây 06 năm; chỉ trong khoảng thời gian ít ỏi đó, chúng ta đã hình thành hàng chục các nhà phát hành, và số trò chơi trực tuyến được phát hành cũng tương ứng với số lượng đó. Nhưng một thực trạng đáng buồn là gần như hầu hết các trò chơi trực tuyến đang được phát hành nhập khẩu từ nước ngoài, chủ yếu là Trung Quốc và Hàn Quốc (trừ một số trò chơi nhỏ chơi trên nền web như đánh bài, đánh cờ…). Một câu hỏi mà có lẽ tất cả người chơi đều trăn trở là “bao giờ mới được chơi game Việt

Nam?”.

Từ thực tế đó, chúng tôi chọn đề tài này không có tham vọng quá lớn, mà chỉ

muốn đi những bước chập chững đầu tiên vào thế giới phát triển game rộng lớn, để thu lượm kiến thức về lĩnh vực khó khăn nhưng đầy thú vị này; và hi vọng ở một tương lai

không xa, chúng tôi có thể góp một phần sức lực giải đáp trăn trở của cộng đồng người chơi game Việt Nam.

Khóa luận nghiên này cứu xây dựng một hệ thống Game Engine đa nền tảng (được đặt tên là GEM) (trước mắt sẽ hỗ trợ Window PC và Linux PC) và nhắm đến thị

trường trò chơi nhập vai trực tuyến. Đây là mục tiêu dài hạn, còn hiện tại, do hạn chế về thời gian (khoảng 5 tháng) nên chúng tôi chỉ tập trung hoàn thiện thành phần

Render Engine trong Game Engine. Để giải quyết vấn đề này, khóa luận tập trung nghiên cứu và phân tích môi trường phát triển đồ họa 3D (gồm cả phần cứng và phần

mềm), các công nghệ đã được triển khai trong một số game engine khác hiện có trên

thị trường. Từ đó khóa luận đưa ra phương pháp và xây dựng hệ thống tổ chức và quản

lý bộ nhớ, cũng như các đối tượng trong khung cảnh 3D.

Ngoài ra, khóa luận cũng nghiên cứu và triển khai các hiệu ứng (ánh sáng, nước,

lửa…), các mô phỏng vật lý (hệ thống hạt, trường lực…), các tối ưu về bộ nhớ, tốc độ

xử lý và thiết kế mô hình đối tượng trong khung cảnh 3D.

Bố cục của khóa luận bao gồm phần mở đầu, phần kết luận và 5 chương nội dung

được tổ chức như sau:

Chương 1: Trình bày các khái niệm về Game Engine, cách tiếp cận và phương

pháp sử dụng để triển khai hệ thống Game Engine đa nền tảng. Ch ương này cũng trình

bày mô hình chung của một Game Engine và một số thành phần cơ bản khác của hệ

thống.

Chương 2: Trình bày các cơ sở lý thuyết để xây dựng nên mô đun Hiệu ứng ánh sáng và vật liệu. Trong đó chương này trọng tâm vào trình bày một cách tổng quan nhất về các lý thuyết được áp dụng để thiết kế và cài đặt mô đun này.

Chương 3: Trình bày mô hình tổng quan của mô đun Hiệu ứng ánh sáng và vật liệu. Đó là đưa ra quan hệ giữa mô đun này với các mô đun khác trong hệ thống, cũng như quan hệ giữa các thành phần trong cùng mô đun.

Chương 4: Trình bày chi tiết việc cài đặt các thành phần cơ bản của mô đun Hiệu ứng ánh sáng và vật liệu. Đó là cấu trúc lớp để quản lý các thành phần của hệ thống, và các luồng điều khiển thực thi.

Chương 5: Trình bày các đánh giá thực nghiệm và các demo tính năng mà mô

đun Hiệu ứng ánh sáng và vật liệu thực hiện được.

Chương 1: TỔNG QUAN VỀ GEM

1.1. Khái niệm Game Engine

Game Engine là một công cụ hỗ trợ, một lớp trung gian ở giữa các ứng dụng

game và nền tảng bên dưới, các thư viện lập trình cấp thấp. Game Engine giúp phát

triển ứng dụng game một cách nhanh chóng và đơn giản, đồng thời cung cấp khả năng

tái sử dụng mã nguồn cao do có thể phát triển nhiều ứng dụng từ một game engine.

Hình 1: Kiến trúc phân tầng của GEM

GEM là một game engine nên dĩ nhiên nó cũng tuân theo mô hình này (Hình 1).

1.2. Mô hình của GEM

1.2.1. Các đặc điểm của GEM

Như đã giới thiệu, GEM hỗ trợ đa nền (Window PC và Linux PC) và nhắm đến

thị trường phát triển game nhập vai trực tuyến, nên GEM có các đặc điểm sau:

Đầu tiên là khả năng chạy đa nền. Để đạt được điều này, GEM sử dụng các bản build khác nhau trên các nền tảng khác nhau (chứ không phải sử dụng thông dịch). Các

đoạn code phụ thuộc nền tảng sẽ được phân chia bằng việc sử dụng các cờ tiền biên dịch, hạn chế tối đa việc sử dụng các lớp ảo – vì việc nằm sẽ làm giảm đáng kể hiệu suất chương trình [4][5]. Cũng vì lí do này chúng tôi lựa chọn OpenGL làm giao diện

lập trình đồ họa 3D cấp thấp cho GEM, do chuẩn OpenGL là chuẩn mở và không bị phụ thuộc vào hệ điều hành; và sử dụng Cg Shading Language làm ngôn ngữ tạo bóng.

Thứ hai, GEM được thiết kế hướng đối tượng và yêu cầu về hiệu năng chạy cao nên chúng tôi sử dụng ngôn ngữ C++ - ngôn ngữ đáp ứng hoàn hảo các điều kiện trên.

Cuối cùng, do GEM nhắm đến thị trường phát triển game nhập vai trực tuyến,

nên sẽ được thiết kế để tương thích với một phạm vi rộng cấu hình phần cứng, dự kiến

sẽ hỗ trợ các card đồ họa hỗ trợ OpenGL 1.4 và Shader 1.0 trở lên (Bảng 1).

Bảng 1: Dòng card đồ họa được GEM hỗ trợ

Hãng sãn xuất Dòng card hỗ trợ

nVIDIA Từ GeForce4 Ti trở lên

ATI Từ Radeon 9500 trở lên

Intel (card tích hợp) Từ Intel® GMA 3100 (chipset G31,Q33) trở lên

1.2.2. Kiến trúc tổng thể

GEM là được chia thành nhiều thành phần để tiện cho việc phát triển và bảo trì.

Cụ thể GEM gồm các thành phần như sau:

Hình 2: Kiến trúc tổng thể của GEM

Do giới hạn về thời gian, nên phạm vi của luận văn này chúng tôi tập trung hoàn

thành các thành phần sau: Giao tiếp với Hệ điều hành, Các kiểu dữ liệu cơ bản,

Render Engine. Những thành phần này đủ để hỗ trợ người sử dụng tạo ra các khung

1.2.2.1. Thành phần Cấu trúc dữ liệu cơ bản

cảnh 3D và tương tác với chúng.

Các kiểu dữ liệu cơ bản là thành phần bao gồm các cấu trúc dữ liệu cơ bản như

mảng động, vector, ma trận…, và các phép toán trên các kiểu dữ liệu đó; cung cấp cho

thành phần khác sử dụng.

Hình 3: Biểu đồ lớp của thành phần Các kiểu dữ liệu cơ bản

Các kiểu dữ liệu này có thể chia thành 02 nhóm chính:

- Các yếu tố trong không gian 3D:

o Vector2, Vector, Vector4: các loại vector biểu diễn tọa độ 2 chiều, 3

chiều và đồng nhất.

o Aabb: hình hộp chữ nhật có các cạnh dọc theo các trục xyz, được mô

tả bằng 2 điểm (xmin, ymin, zmin ), (xmax, ymax, zmax).

o Sphere: hình cầu được mô tả bởi tọa độ tâm và bán kính. o LineSequent, Line, Ray: mô tả đoạn thẳng, đường thẳng, và tia. o Matrix: ma trận sử dụng để biểu diễn các phép biến đổi: dịch, xoay, co

giãn trong không gian 3 chiều.

o Plane: mặt phẳng được mô tả bởi phương trình ax + by + cz + d = 0. o Frustum: là hình chóp cụt biểu diễn khung nhìn của camera, được mô

tả bằng 6 mặt phẳng tạo nên nó.

- Các kiểu đối tượng lưu trữ:

1.2.2.2. Thành phần Giao tiếp với Hệ điều hành

o String: lưu trữ xâu kí tự. o Array: mảng động có thể tùy biến với hệ số mở rộng. o GemAllocator: thực thi cấp phát và giải phóng bộ nhớ. o List: Danh sách liên kết hai chiều. o Stack: đặc tả ngăn xếp.

Hình 4: Quá trình điều phối sự kiện

Giao tiếp với Hệ điều hành là thành phần thực thi các công việc cần giao tiếp

với hệ điều hành như điều phối sự kiện, đọc ghi file, lấy thời gian hệ thống… Trong đó

quan trọng nhất là quá trình điều phối sự kiện (Hình 4).

GEM lấy sự kiện từ Message System của hệ điều hành, từ đó lấy các thông tin

cần thiết tạo ra một đối tượng GemEvent - lý do cần tạo ra GemEvent là để tránh bị

phụ thuộc vào hệ điều hành. Sau đó, GemEvent sẽ được gửi lần lượt đến các thành

1.2.2.3. Thành phần Render Engine

phần có khả năng nhận và xử lý sự kiện này.

Render Engine là thành phần cốt lõi của một Game Engine. Nó hỗ trợ người

dùng các công việc thiết yếu để tạo ra một khung cảnh 3D. Người dùng sẽ không cần

biết nhiều đến những công việc tầng thấp như quá trình đọc file tài nguyên, sử dụng

các API đồ họa 3D, tạo các hiệu ứng… mà quản lý logic các đối tượng bằng các giao

diện do Render Engine cung cấp.

Đây là thành phần duy nhất trong GEM giao tiếp với phần cứng đồ họa thông

qua thư viện đồ họa 3D cấp thấp, cụ thể ở đây là OpenGL và Cg.

Hình 5: Kiến trúc phân tầng của Render Engine

Thành phần này được thiết kế làm các mô đun sau:

- Graphic Driver là mô đun trực tiếp sử dụng các API đồ họa 3D (OpenGL),

cung cấp cho các mô đun khác một giao diện đơn giản hơn để tương tác với card đồ họa.

- Quản lý tài nguyên là mô đun quản lý các tài nguyên cần thiết để xây dựng một

khung cảnh 3D như mạng lưới, texture 2D, cubemap… Mô đun này được trình

bày chi tiết trong khóa luận “Xây dựng Game Engine đa nền tảng – Quản lý tài

nguyền và chuyển động nhân vật ” - Hoàng Tuấn Hưng.

- Quản lý khung cảnh là mô đun thực hiện việc tổ chức và kiểm soát các đối

tượng tồn tại trong một khung cảnh 3D, từ đó thực hiện quá trình chuyển toàn bộ

khung cảnh đó tạo nên hình ảnh 2D tại vị trí nhìn. Mô đun này được trình bày chi tiết trong khóa luận “Xây dựng Game Engine đa nền tảng – Quản lý khung

cảnh” - Trương Đức Phương.

- Hiệu ứng ánh sáng và vật liệu là mô đun mở rộng các thành phần của Quản lý

khung cảnh để tạo các hiệu ứng về ánh sáng, và vật liệu. Mô đun này được trình

bày chi tiết ở phần sau của khóa luận này.

- Mô phỏng tự nhiên là mô đun mở rộng các thành phần của Quản lý khung cảnh để mô phỏng các yếu tố tự nhiên cần có trong game như nước, địa hình, lửa, khói… Mô đun này được trình bày chi tiết trong khóa luận “Xây dựng Game Engine đa nền tảng – Mô phỏng tự nhiên” - Trần Thái Dương.

1.2.2.4. Các thành phần còn lại

- Chuyển động của đối tượng là mô đun mở rộng các thành phần của Quản lý hung cảnh, thực hiện quá trình nội suy trong các mô hình chuyển động (thường là các nhân vật trong game) thông qua hai kĩ thuật thông dụng là keyframe và skinning. Mô đun này được trình bày chi tiết trong khóa luận “Xây dựng Game Engine đa nền tảng – Quản lý tài nguyền và chuyển động nhân vật” - Hoàng Tuấn Hưng.

Phát hiện va chạm và Tính toán vật lý là thành phần tính toán mô phỏng vật lí,

phát hiện va chạm giữa các vật thể và phản hồi.

Network là thành phần thực hiện việc truyền thông qua mạng TCP/IP.

Trí thông minh nhân tạo là thành phần xử lí các công việc cần trí thông minh

nhân tạo như dò đường, xử lí tình huống…

Âm thanh là thành phần xử lí âm thanh.

Các thành phần này chưa được triển khai nên chúng tôi không đề cập chi tiết trong tài liệu này.

Chương 2: CƠ SỞ LÝ THUYẾT

2.1. Ánh sáng trong đồ họa máy tính

Đồ họa 3D ngoài việc sử dụng các thuật toán giống với đồ họa 2D như: đồ họa

vectơ trong mô hình khung dây (wire frame model) và đồ họa mành (raster graphics)

trong giai đoạn hiển thị cuối cùng. Bên cạnh đó, đồ họa 3D còn thực hiện chiếu sáng

bằng các mô hình tạo bóng, dựa vào các thông tin về nguồn sáng và nguyên liệu cấu

tạo nên bề mặt đối tượng, để tính toán màu sắc của đối tượng trong khung cảnh; tạo ra

hình ảnh gần với thực tế hơn (khoảng cách xa gần giữa các đối tượng, vật liệu tạo nên

đối tượng…).

Hình 6: Tác động của Ánh sáng trong đồ họa 3D

2.1.1. Các thành phần của ánh sáng

Mỗi nguồn sáng được chia làm ba thành phần sáng cơ bản [7][12]:

Thành phần Ambient

Thành phần ánh sáng bao quanh vật thể, và đến từ mọi hướng. Vì thế nó không phụ thuộc vào vị trí của nguồn sáng mà phụ thuộc vào độ phản xạ ánh sáng của vật thể

và màu sắc của nguồn sáng.

Hình 7: Vẽ vật thể với áng sáng Ambient

Thành phần Diffuse

Thành phần ánh sáng đến từ một nguồn sáng cụ thể, sau đó phản xạ tại bề mặt vật thể theo nhiều hướng. Màu sắc của vật thể được chiếu sáng bởi thành phần này phụ thuộc vào vị trí, hướng, màu sắc của nguồn sáng và độ phản xạ của vật thể.

Hình 8: Vẽ vật thể với thành phần Diffuse

Thành phần Specular

Thành phần ánh sáng này cũng đến từ một nguồn sáng cụ thể, nhưng khác với

thành phần diffuse là nó phản xạ theo một hướng theo đúng định luật phản xạ gương.

Quá trình chiếu sáng ngoài phụ thuộc vào vị trí, hướng, màu sắc của nguồn sáng; độ

phản xạ ánh sáng của vật thể, còn phụ thuộc vào hướng nhìn của mắt.

Hình 9: Vẽ vật thể với thành phần Specular

Ngoài ra, mỗi nguồn sáng còn có một số đặc trưng riêng, mô tả cho các loại nguồn sáng khác nhau, như: hướng ánh sáng, vị trí nguồn sáng, cường độ ánh sáng và vùng giới hạn chiếu sáng…

2.1.2. Các mô hình tạo bóng

Mô hình tạo bóng định nghĩa cách tính toán màu sắc dựa vào thông tin về nguồn

sáng và đối tượng được chiếu sáng [7][12].

Các mô hình tạo bóng khác nhau, thì triển khai tính toán các thành phần ánh sáng khác nhau; tạo ra các hình ảnh khác nhau với cùng một thông tin đầu vào của nguồn

sáng và đối tượng được chiếu sáng.

Hình 10: Kết quả của một số mô hình tạo bóng

Bên cạnh đó, việc triển khai mô hình tạo bóng dựa vào vertex hay fragment (hay

pixel) cũng tạo ra kết quả khác nhau. Với cùng một vật thể, cùng một mô hình tạo

bóng, nhưng mô hình này triển khai theo chương trình pixel thì cho kết quả tốt hơn.

Các triển khai của OpenGL đều triển khai mô hình ánh sáng Phong, và thực thi trên

chương trình vertex.

Hình 11: Kết quả của cùng một mô hình ánh sáng trên Vertex và Pixel

2.2. Đổ bóng

2.2.1. Bóng của đối tượng trong khung cảnh

Các đối tượng trong khung cảnh 3D, ngoài sự khác nhau về màu sắc của các bề

mặt so với nguồn sáng, còn có các vùng tối mà ánh sáng không chiếu đến được. Vùng tối này gọi là bóng của vật thể.

Quá trình chiếu sáng dựa vào thực thi của OpenGL không tạo ra bóng, nên quá trình vẽ bóng của vật thể được tính toán như một đối tượng độc lập dựa vào thông tin

về vị trí, cấu trúc (các đỉnh, cạnh và mặt của vật thể tạo bóng).

2.2.2. Phương pháp đổ bóng

Có nhiều phương pháp tạo bóng khác nhau như: bản đồ độ sâu (depth map), vùng

đổ bóng (shadow volume) …

Đổ bóng trong GEM triển khai kĩ thuật vùng đổ bóng [1][2][6].

Vùng đổ bóng (SV) là một model gồm:

- Mặt nhận sáng (Light Cap): tập các đa giác có pháp tuyến hướng về phía nguồn

sáng.

- Mặt tối (Dark Cap): tập các đa giác có pháp tuyến hướng ra xa nguồn sáng.

- Cạnh bên (Shadow side): là mặt đa giác chứa hai đỉnh v0, v1 của cạnh nằm giữa

mặt nhận ánh sáng và một mặt tối; và hai đỉnh này được đưa ra vô cực.

Hình 12: Mô hình của SV

Bóng của vật thể được xác định bằng những điểm nằm trong vùng SV. Xác định các điểm P này bằng cách tính số giao điểm của tia nh ìn hướng đến P với các cạnh của vùng đổ bóng [6].

2.3. Đối tượng có bề mặt phức tạp

2.3.1. Đối tượng với mạng lưới nhiều đa giác

Các đối tượng trong đồ họa máy tính 3D được xấp xỉ theo các mô hình có mạng lưới (mesh) gồm nhiều đa. Mức độ chi tiết của đối tượng các cao thì số lượng đa giác

càng lớn. Điều đó đồng nghĩa với chi phí thiết kế, lưu trữ và vẽ đối tượng tăng.

Về cơ bản, các chi tiết khác nhau chỉ được nhận thấy khi vật thể được chiếu sáng,

do vector pháp tuyến của từng mặt đa giác khác nhau.

2.3.2. Kỹ thuật sử dụng bản đồ vector pháp tuyến

Quá trình chiếu sáng bề mặt vật thể dựa vào bản đồ vector pháp tuyến được lưu trong một ảnh bitmap, hay còn gọi là kỹ thuật bump [7][10]. Kỹ thuật này cho phép

tạo ra:

- Bề mặt phức tạp mà không cần nhiều đa giác tạo nên vật thể dựa vào hiệu ứng

phản xạ của ánh sáng.

- Áp dụng nhiều loại bề mặt cho cùng một mô hình mà không phải thiết kế

nhiều mô hình khác nhau

Hình 13: So sánh giữa sử dụng bản đồ pháp tuyến và thiết kế mô hình

Mỗi vector pháp tuyến ứng với một pixel trong ảnh bitmap. Vector pháp tuyến là vector ba chiều và khoảng giá trị của mỗi thành phần nằm trong khoảng [-1,1]. Trong khi đó, mỗi pixel trên ảnh bitmap là một bộ gồm ba thành phần và khoảng giá trị của các thành phần trong khoảng [0, 1]. Vì vậy, cần phải chuyển đổi qua

lại giữa các giá trị trong hai khoảng trên [7]:

- Công thức chuyển đổi từ vector pháp tuyến sang màu của pixel

colorComponent = 0.5 * normalComponent + 0.5

- Công thức chuyển đổi ngược lại

normalComponent = 2 * (colorComponent - 0.5)

2.3.3. Không gian Texture

Để triển khai kỹ thuật bump, bản đồ pháp tuyến thường được tạo ra và lưu theo dạng bản đồ độ cao (height map) – pháp tuyến tại một điểm được tính thông qua độ cao của các đỉnh xung quanh và bản đồ này được lưu trong không gian Texture [7].

Do đó, cần phải chuyển đổi qua lại từ không gian Texture và không gian World

[9]. Ma trận chuyển đổi TBN được định nghĩa như sau:

Tx Ty Tz

TBN = Bx By Bz

Nx Ny Nz

Với T = (Tx Ty Tz) là thành phần tiếp tuyến, B = (Bx By Bz) là thành phần phó pháp

tuyến, N = (Nx Ny Nz) là thành phần pháp tuyến.

Chương 3: MÔ HÌNH ĐỀ XUẤT

3.1. Các yêu cầu chung của mô đun

Các thành phần của mô đun được thiết kế để đảm bảo:

- Các nút được tổ chức và quản lý theo dạng cây của đồ thị khung cảnh 3D scenegraph, tức là các nút này được quản lý bởi mô đun Quản lý khung cảnh. - Toàn bộ tài nguyên gồm dữ liệu về vật liệu, mạng lưới đa giác và các chương trình tạo bóng bằng ngôn ngữ Cg được quản lý bởi mô đun Quản lý tài

nguyên.

- Các hiệu ứng về ánh sáng được triển khai bằng ngôn ngữ tạo bóng Cg, được lưu vào file với phần mở rộng .cgfx và .cgh. Các nút xử lý cùng một hiệu ứng

thì được gắn với một triển khai này (tham chiếu đến định danh của hiệu ứng). Các chương trình tạo bóng này được biên dịch trong thời điểm thực thi (runtime) nhờ các API của thư viện Cg (Cg lib).

Hình 14: Mô hình liên kết với các thành phần khác bên ngoài

Bên cạnh đó, mô đun này còn xây dựng một hệ thống chiếu sáng có cơ chế hoạt

động giống với cơ chế chiếu sáng của OpenGL cung cấp, nhưng có tính khả chuyển cao giữa các mô hình tạo bóng.

3.2. Các thành phần trong mô đun

Hình 15: Các thành phần của mô đun Hiệu ứng ánh sáng và vật liệu

Để đảm bảo các yêu cầu đặt ra, mô đun chia các thành phần thành ba nhóm cơ

bản:

- Nhóm thứ nhất bao gồm các thành phần đóng vai trò là các nút trong cây đồ thị khung cảnh scenegraph như các lớp LightSceneNode, DLightSceneNode,

BumpSceneNode, và SolidSceneNode được dẫn xuất từ lớp SceneNode; và

lớp Shadow. Đây là các lớp định nghĩa đối tượng trong khung cảnh 3D. Trong đó, lớp LightSceneNode và DLightSceneNode là các đối tượng trừu

tượng, có nhiệm vụ lưu thông tin về nguồn sáng. Các lớp còn lại là các đối tượng được hiển thị trực quan trên màn hình.

- Nhóm thứ hai gồm các lớp dẫn xuất từ lớp Parameter: ShadowParameter, DLightParameter, và BumpParameter. Các lớp này lưu thông tin cần thiết

tương ứng với các thông tin lưu trong các nút, phục vụ cho quá trình cập nhật tham số cho chương trình tạo bóng trong thời điểm thực thi.

- Nhóm thứ ba gồm các lớp dẫn xuất từ lớp Effect: DLightEffect, ShadowEffect, và BumpEffect. Đây là các lớp gắn với một triển khai hiệu

ứng trên ngôn ngữ Cg, và chứa các điều khiển cập nhật thông tin cho chương

trình tạo bóng này.

Chi tiết cài đặt chức năng của các lớp này được trình bày ở chương sau.

Chương 4: THIẾT KẾ CHI TIẾT

4.1. Chiếu sáng

Quá trình chiếu sáng trong đồ họa máy tính được thực hiện giống với quá trình

hoạt động của đèn ở thế giới thực. Các bước thực hiện như sau (Hình 16):

- Bật nguồn sáng: thiết lập các thông số về nguồn sáng nh ư vị trí, hướng, vùng

chiếu sáng và thuộc tính của các thành phần sáng.

- Vẽ các đối tượng: Mỗi đối tượng được gắn với một Render Context (Xem Mô đun Quản lý Khung cảnh) và chỉ những đối tượng nào đăng ký được

chiếu sáng thì mới được chiếu sáng.

- Tắt nguồn sáng: hủy bỏ các thông số đã thiết lập cho từng nguồn sáng.

Hình 16: Quá trình Chiếu sáng

Nguồn sáng ở trong GEM là một đối tượng trừu tượng - chỉ lưu thông tin mà không hiển thị trực quan trong khung cảnh 3D; tuy nhiên, nó lại được quản lý như một

nút trong cây khung cảnh scenegraph.

4.1.1. Vật liệu

Vật liệu định nghĩa tính chất phản xạ ánh sáng của bề mặt vật thể, bao gồm các

thành phần cấu thành sau: illum mô tả mô hình tạo bóng được sử dụng; Ka, Kd, Ks lần

lượt mô tả các tính chất phản xạ các thành phần ánh sáng đã nêu ở chương trước của

bề mặt; và Ni mô tả độ bóng của bề mặt khi tính độ phản xạ specular.

Hình 17: Lớp Material

Các tính chất vật liệu này được thiết kế trước cho từng mạng lưới của mô hình

vật thể và được tải vào thông qua phương thức loadFromMtl() (Xem chi tiết ở Mô đun Quản lý tài nguyên). Trong quá trình vẽ đối tượng, vật liệu được thiết lập trước.

4.1.2. Chiếu sáng bằng mô hình OpenGL cung cấp

OpenGL cung cấp các API để định nghĩa nguồn sáng, thiết lập thông số về vật

liệu cho các đối tượng được chiếu sáng bởi nguồn sáng.

Hình 18: Lớp LightSceneNode

Mỗi nguồn sáng cũng được coi là một nút, tức là lớp LightSceneNode dẫn xuất

lớp SceneNode. Ngoài những lưu ở SceneNode, tin được

từ lớp thông LightSceneNode lưu thông tin về Loại nguồn sáng (type), hướng (direction), cường độ các thành phần ánh sáng (Ka, Kd, Ks), góc giới hạn vùng chiếu sáng (outerCone), và sự thay đổi cường độ sáng theo khoảng cách (kC, kL, kQ). Phương thức render() được

lớp LightSceneNode triển khai quá trình “bật” nguồn sáng bằng các câu lệnh OpenGL.

Như đã giới thiệu, ngoài ba thành phần sáng cơ bản, nguồn sáng còn có những

tính chất riêng đặc tả sự khác nhau giữa các nguồn sáng. Dựa vào các tính chất này, GEM chia các nguồn sáng được chia làm 04 loại sau:

- Nguồn sáng môi trường (ambient light): nguồn sáng mô tả ánh sáng môi trường, có cường độ và màu sắc đồng đều ở mọi nơi trong khung cảnh 3D. - Nguồn sáng điểm (point light): nguồn sáng mô tả ánh sáng phát ra từ một vị trí xác định trong khung cảnh 3D, phát ra theo mọi hướng và có cường độ

giảm dần theo khoảng cách.

- Nguồn sáng có góc giới hạn chiếu (spot light): nguồn sáng này giống với nguồn sáng điểm, chỉ khác là ánh sáng phát ra trong một vùng giới hạn nhất định – vùng giới hạn này được đặc trưng bởi hình nón có đỉnh ở vị trí nguồn

sáng và đường cơ sở hợp với trục chính một góc outerCone (ví dụ như đèn

học, đèn sân khấu).

- Nguồn sáng có hướng song song (directional light): nguồn sáng này mô tả các nguồn sáng ở rất xa vật bị chiếu sáng, và có cường độ sáng gần như

không đổi (ví dụ như mặt trời). Loại nguồn sáng này chỉ cần quan tâm đến

hướng ánh sáng.

Hình 19: Sơ đồ “bật” nguồn sáng

Do loại nguồn sáng được đặc trưng bởi các thuộc tính khác nhau, nên quá trình

“bật” nguồn sáng của từng loại cũng khác nhau, theo các bước sau (Hình 19):

- Cập nhật ma trận Model: tính lại ma trận và định lại vị trí mới trong trong

khung cảnh 3D nếu có sự thay đổi vị trí của nguồn sáng.

- Thiết lập vị trí, Cường độ, Màu sắc các thành phần sáng: Các bước này

được thực hiện với tất cả các loại nguồn sáng.

- Nếu nguồn sáng là:

+ Nguồn sáng có góc giới hạn chiếu: Thiết lập vùng chiếu sáng. + Nguồn sáng có hướng song song: Thiết lập hướng chiếu sáng.

Các thiết lập thông số này sử dụng phương thức glLightfv(GLenum light, GLenum

pname, const GLfloat * params) [8][12].

4.1.3. Chiếu sáng bằng mô hình tự định nghĩa

Như đã giới thiệu, OpenGL cung cấp mô hình tạo bóng Phong và thực thi trên

chương trình tạo bóng theo từng đỉnh (vertex progam), nên có một số hạn chế:

- Quá trình nội suy màu sắc theo các đỉnh không được chính xác, đặc biệt là

quá trình chiếu sáng với nguồn sáng có vùng giới hạn chiếu.

- Phải thiết kết mô hình chi tiết hơn (nhiều đa giác hơn) nếu muốn có kết quả tốt, nhưng tốc độ sẽ giảm đi đáng kể trong khi bộ nhớ lưu trữ mô hình tăng.

4.1.3.1. Lớp DLightSceneNode

Như vậy, chúng ta cần phải triển khai một cơ chế như OpenGL cung cấp nhưng cho phép lựa chọn mô hình tạo bóng khác nhau (như Blinm, Lambert…), thứ nữa là tạo ra kết quả hình ảnh tốt bằng cách thực thi mô hình tạo bóng này theo chương trình tạo bóng theo từng pixel (fragment program).

Hình 20: Lớp DLightSceneNode

Lớp DLightSceneNode được thiết kế như là một đối tượng lưu thông tin về

nguồn sáng, và truyền các thông số này cho các nút khác có đăng ký sử dụng hiệu ứng

ánh sáng.

Lớp DLightSceneNode được dẫn xuất từ lớp LightSceneNode.

DLightSceneNode có thêm các thành phần parameter, dlight_effectID và using_IDs.

Thành phần parameter là một đối tượng DLightParameter, các thành phần cấu thành

nên đối tượng này tương ứng với các thành phần trong DLightSceneNode – các thông tin về nguồn sáng. Thành phần dlight_effectID là một tham chiếu định danh đến một

đối DLightEffect – được quản lý bởi mô đun quản lý tài nguyên. Thành phần

using_IDs chứa danh sách các định danh của các Effect và dẫn xuất của nó mà có đăng

ký sử dụng hiệu ứng ánh sáng; danh sách này cập nhật động khi có Effect mới được

khởi tạo.

Hình 21: Sơ đô trạng thái “bật” nguồn sáng động

Phương thức render() của lớp DLightSceneNode thực hiện “bật” nguồn sáng và

cập nhật tham số của Effect cho các nút sử dụng DLightSceneNode (Hình 21):

- Cập nhật ma trận Model: tính lại ma trận model và định lại vị trí nếu nguồn

sáng thay đổi vị trí.

- Bật nguồn sáng bằng OpenGL: gọi phương thức render() của lớp cơ sở

LightSceneNode.

- Cập nhật DLightParameter: gọi phương thức updateParameters(), thực

hiện cập nhật tham số của đối tượng parameter.

- Cập nhật DLightEffect: cập nhật các tham số về nguồn sáng cho đối tượng

dlight_effectID và các đối tượng có trong danh sách using_IDs.

Lớp DLightEffect được thừa kế từ lớp Effect. Lớp này gồm các thành phần

hLighti* là các tham số lưu thông tin của tất cả các nguồn sáng có trong hệ thống – với

triển khai trong GEM là 10 nguồn sáng (0≤i≤10). Nguồn sáng thứ i được bật, phương

thức updateEffecParameter() được gọi để cập nhật tham số cho hLighti*, và gọi

phương thức updateLightParameter() cập nhật tham số nguồn sáng cho đối tượng trong using_IDs của DLightSceneNode.

Hình 22: Lớp DLightEffect

GEMDlight.cgfx chứa chương trình fragment shader, triển khai mô hình tạo

bóng; và việc chuyển đổi giữa các mô hình ánh sáng bằng cách gắn lại các chương trình Cg được triển khai trong file GEMDLight.cgfx. Chương trình dưới đây triển khai

mô hình tạo bóng Phong, với tham số đầu vào là nguồn sáng light gồm (loại, vị trí, hướng, thành phần ambient, diffuse, specular, cường độ, và góc giới hạn), hướng nhìn

V, điểm được chiếu sáng P, và tính chất vật liệu gMaterial . Quá trình này thực hiện như sau:

- Tính cường độ sáng attenuation tại điểm P, cường độ này giảm dần theo

khoảng cách từ nguồn sáng đến P.

- Tính vùng chiếu sáng spotEffect, nếu là nguồn sáng spotlight thì vùng này là

một hình nón có đỉnh là vị trí nguồn sáng.

- Tính các thành phần sáng ambient, diffuse và specular dựa vào hướng nhìn,

hướng chiếu sáng và điểm được chiếu sáng.

- Tính màu tại điểm P dựa vào các thành phần sáng và vật liệu tại điểm P.

Chương trình fragment shader được triển khai trong GEMDLight.cgfx

float4 lightPS() : COLOR

{

float attenuation = calculateAttenuation(P, light); //tính cường độ sáng

float spotEffect = calculateConeSpotlight(P, light); //tính vùng chiếu sáng

//tính thành phần ambient

ambientResult = light.Ka * attenuation * spotEffect;

//tính thành phần diffuse

float3 L = normalize(light.position.xyz - P);

L = normalize(-light.direction.xyz);

specularLight = 0;

if(light.type == 3) //nguồn sáng có hướng song song float diffuseLight = max(dot(N, L), 0); diffuseResult = light.Kd * diffuseLight * attenuation * spotEffect; //tính thành phần specular float3 H = normalize(L + V); float specularLight = pow(max(dot(N, H), 0), shininess); if (diffuseLight <= 0) specularResult = light.Ks * specularLight * attenuation * spotEffect;

4.1.3.2. Sử dụng DLightSceneNode

return gMaterial*(ambientResult + diffuseResult + specularResult); }

Hình 23: Ví dụ về một lớp sử dụng DLightSceneNode

Giả sử lớp UsingDlightSceneNode dẫn xuất từ lớp SolidSceneNode dùng để định

nghĩa một đối tượng sử dụng hiệu ứng ánh sáng. Lớp này có parameter chứa tham số

cập nhật cho đối tượng UsingEffect có định danh tham chiếu là using_ID. Lớp

UsingDLightSceneNode cần cung cấp phương thức cập nhật parameter là

updateParameter(), phương thức vẽ đối tượng ra khung cảnh 3D render().

Tất cả các đối tượng sử dụng hiệu ứng ánh sáng đăng ký bằng cách cập nhật danh

sách using_IDs của lớp DLightSceneNode trong quá trình khởi tạo. Sau đó, trong quá trình “bật” nguồn sáng, các nguồn sáng sẽ cập nhật thông tin của chính nó cho các

Effect mà có định danh tương ứng trong danh sách using_IDs.

Hình dưới đây mô tả quá trình bật nguồn sáng và vẽ đối tượng sử dụng hệ thống

áng sáng động:

- Khởi tạo đối tượng, UsingEffect cập nhật mình vào danh sách using_IDs

của DLightSceneNode.

- “Bật” nguồn sáng, DLighSceneNode cập nhật tham số về nguồn sáng cho

các đối tượng trong có trong using_IDs.

- Vẽ đối tượng, UsingDLightSceneNode cập nhật các tham số riêng của mình

cho parameter và usingeffect_id, sau đó gọi lệnh vẽ mạng lưới.

Hình 24: Quá trình chiếu sáng bằng hệ thống ánh sáng động

4.2. Hiệu ứng đổ bóng

Hình 25: Lớp Shadow

Lớp Shadow đặc tả cho bóng của một đối tượng trong khung cảnh 3D. Thành phần cấu tạo nên lớp Shadow gồm shadowVolume và shadowColor. Thành phần shadowVolume lưu mạng lưới đa giác của vùng giới hạn đổ bóng (SV). Thành phần shadowColor định nghĩa màu của bóng.

Lớp Shadow cung cấp phương thức render() để vẽ bóng. Quá trình Vẽ bóng thực

hiện vẽ SV hai lần vào Stencil Buffer (SB):

Hình 26: Sơ đồ trạng thái vẽ bóng

- Lần đầu tăng giá trị của SB tại những điểm nằm sau mặt trước của SV

glCullFace(GL_FRONT);

glStencilFunc(GL_ALWAYS, 0x0, 0xff);

glStencilOp(GL_KEEP, GL_INCR, GL_KEEP);

- Lần thứ hai giảm giá trị của SB tại những điểm nằm sau mặt sau của SV

glCullFace(GL_BACK);

glStencilFunc(GL_ALWAYS, 0x0, 0xff); glStencilOp(GL_KEEP, GL_DECR, GL_KEEP);

Kết quả là những điểm nằm trong vùng đổ bóng có giá trị trong SB khác 0.

Mỗi nút SolidMeshSceneNode đăng ký vẽ bóng sẽ được gắn với một đối tượng

Shadow và được xếp vào ngữ cảnh vẽ ERL_SHADOW_VOLUME thông qua phương

thức bindToRenderList(). SV được tính toán lại khi có sự thay đổi vị trí của nút

SolidSceneNode gắn với nó hoặc thay đổi của nguồn sáng bằng cách gọi phương thức updateShadowVolume() của lớp Shadow. Như vậy, tốc độ vẽ sẽ giảm đi đáng kể nếu có sự thay đổi này. Để khắc phục tình trạng này, thực hiện một số cải tiến sau:

- Mỗi nút SolidSceneNode không lưu một SV nữa, mà lưu nhiều SV hơn, cụ thể là mỗi SV tương ứng với một nguồn sáng. Như vậy, chỉ tính lại SV khi nguồn sáng thay đổi vị trí.

- Chuyển một phần tính toán SV lên cho phần cứng đồ họa (GPU). Shadow gắn một ShadowEffect bằng một tham chiếu định danh shadow_effectID và một ShadowParameter là parameter. Mỗi ShadowEffect đảm nhiệm việc kiểm tra và chuyển điểm đấy ra vô cực – được triển khai trong file GEMShadow.cgfx,

còn việc xác định mặt nhận sáng hay không vẫn được thực hiện trên CPU.

Hình 27: Lớp ShadowEffect

- Với thiết kế ban đầu, mỗi mạng lưới (đối tượng thuộc lớp Mesh) lưu thông tin các đỉnh (Xem chi tiết tổ chức lưu trữ trong mô đun Quản lý tài nguyên). Do

đó, việc xác định các mặt kề nhau trong tính toán SV mất nhiều thời gian hơn.

Mỗi đối tượng Mesh sẽ lưu thêm thông tin về các mặt Face (lưu các đỉnh tạo

nên mặt đó) và các cạnh Egde (lưu các hai mặt kề và hai đỉnh tạo nên cạnh)

[2][6]; các thông tin này được khởi tạo bằng các phương thức của lớp Mesh

lần lượt tương ứng là calculateFaces() và calculateEdges()

Hình 28: Cấu trúc dữ liệu tính toán Vùng đổ bóng

File GEMShadow.cgfx triển khai chương trình vertex shader thực hiện việc chuyển một đỉnh vIn(x, y, z, w) đến vô cực theo hướng từ ánh sáng đến đỉnh này nếu thành phần w của vIn bằng 0.

Chương trình vertex shader được triển khai trong GEMShadow.cgfx

float4 shadowVP(float4 vIn) : POSITON {

float4 vOut; if(vIn.w ==0) /*chuyển ra vô cực theo hướng ánh sáng*/

vOut = mul(gModelViewProjMatrix, vIn.xyz * gLightPos.w - gLightPos.xyz); else vOut = vIn;

return vOut; }

Lớp SolidMeshSceneNode cần cung cấp phương thức vẽ bóng renderShadow().

Phương thức này hoạt động như sau (Hình 29):

- Kiểm tra xem đối tượng có được vẽ bóng không? Kiểm tra đối tượng có

nằm trong vùng chiếu sáng của một nguồn sáng.

- Kiểm tra xem có cần tính lại SV hay không? Dựa vào các cờ trạng thái làm

thay đổi ma trận model của nguồn sáng và của chính đối tượng

- Cập nhật tham số cho parameter - Cập nhật tham số cho shadow_effect_id - Vẽ bóng: vẽ vùng đổ bóng vào SB.

Hình 29: Sơ đồ hoạt động của renderShadow()

4.3. Hiệu ứng Bump

Hình 30: Lớp BumpSceneNode

Lớp BumpSceneNode được thừa kế từ lớp cơ sở SolidSceneNode. Lớp

BumpSceneNode có thêm các thành phần normalSampler là một Texture lưu bản đồ

pháp tuyến, bump_effectID tham chiếu định danh đến một đối tượng BumpEffect,

parameter là một đối tượng BumpParameter chứa tham số cập nhật cho BumpEffect

(bản đồ pháp tuyến normalSampler, và texture của bề mặt textureSampler).

Do bản đồ pháp tuyến được lưu trong không gian texture, vì vậy, cần phải tính

ma trận TBN chuyển từ không gian World sang không gian Texture (Hình 31). Ma trận TBN này được tính cho từng mặt của vật thể dựa vào thông tin về tọa độ texture

(texcoordinate) và tọa độ các đỉnh của mặt (vertex) [9].

Hình 31: Tính ma trận chuyển từ không gian World sang không gian Texture

Để tăng tốc độ vẽ, thực hiện các biện pháp sau:

- Chỉ tính thành phần pháp tuyến normal bằng phương thức calculateNormal(), và tiếp tuyến tangent bằng phương thức calculateTangent() trên CPU. Còn thành phần phó pháp tuyến binormal được tính trên GPU, theo công thức

binormal = crossProduct(normal, tangent) (tích có hướng của hai vector). - Giảm số lượng lời gọi hàm vẽ của hệ thống bằng cách vẽ toàn bộ vật thể

trong một lời gọi thay vì vẽ từng mặt của vật thể.

Lớp BumpEffect dẫn xuất từ lớp DLightEffect, và triển khai tính toán hiệu ứng

bump trong file GEMBump.cgfx. Quá trình khởi tạo đối tượng thuộc lớp này sẽ kèm

thêm quá trình cập nhật động danh sách using_IDs của lớp DLightSceneNode. Như

vậy, các thông số về nguồn sáng của đối tượng sẽ được cập nhật trong quá trình “bật”

nguồn sáng bằng lời gọi phương thức updateLightParameter(). Phương thức

updateEffectParameter() thực hiện cập nhật bản đồ pháp tuyến và texture bề mặt.

Hình 32: Sơ đồ lớp BumpEffect

Trên GPU, triển khai tính toán để tọa hiệu ứng bump từ các tham số được truyền vào: hướng ánh sáng lightVec, hướng nhìn viewVec, tọa độ texture texCoord, thành phần pháp tuyến N và tiếp tuyến T của ma trận TBN, và bản đồ pháp tuyến gNormalSampler. Trước hết là tính thành phần phó pháp tuyến B; sau đó, chuyển lightVec và viewVec từ không gian World sang không gian Texture; cuối cùng, thực hiện tính toán màu sắc tại điểm vIn bằng một mô hình ánh sáng.

Chương trình fragment shader được triển khai trong GEMBump.cgfx

float4 bump_PS(float4 vIn) : COLOR {

//Lấy thông pháp tuyến của vIn từ bản đồ pháp tuyến float3 normalTex = tex2D(gNormalSampler, texCoord).xyz;

normalTex = expand(normalTex); //Tính phó pháp tuyến và ma trận TBN

float3 B = T.w * cross(N, T.xyz); float3x3 TBN = float3x3(T.xyz, B, N);

//Chuyển từ không gian Word sang không gian Texture lightVec = mul(TBN, lightVec);

viewVec = mul(TBN, viewVec); return lighting(lightVec, normalTex, viewVec);

}

Lớp BumpSceneNode cung cấp phương thức vẽ một đối tượng sử dụng hiệu ứng

bump trong khung cảnh 3D; phương thức này hoạt động như sau:

- Cập nhật ma trận Model: tính lại ma trận model của đối tượng nếu có sự

thay đổi vị trí, hoặc kích thước.

- Tính thành phần pháp tuyến của ma trận TBN - Tính thành phần tiếp tuyến của ma trận TBN - Cập nhật tham số cho parameter - Cập nhật tham số cho bump_effectID: cập nhật các tham số trong chương

trình shader.

- Vẽ đối tượng: quá trình này truyền dữ liệu của mạng lưới vào cho chương

trình shader.

Hình 33: Sơ đồ hoạt động của phương thức render() của BumpSceneNode

Chương 5: THỰC NGHIỆM

5.1. Thực nghiệm chương trình

5.1.1. Phương pháp đánh giá

Đây là một hệ thống xử lý đồ họa nên được đánh giá theo các tiêu chí: Tốc độ

khung hình, chất lượng hình ảnh và khối lượng bộ nhớ. Trong đó tốc độ khung hình là

yếu tố then chốt, quyết định đến tính chân thực của hình ảnh và tương tác.

Các thực nghiệm sẽ xây dựng một khung cảnh 3D từ GEM và đánh giá với sự

thay đổi về ánh sáng:

- Thực nghiệm 1: Đánh giá tốc độ khung hình cho Ứng dụng trò chơi cờ vua

3D (Hình 35) với hai hệ thống ánh sáng được xây dựng.

- Thực nghiệm 2: Đánh giá tốc độ khung hình cho tính đổ bóng cho các quân

cờ trong Ứng dụng ở thực nghiệm 1.

- Thực nghiệm 3: Đánh đánh giá chất lượng hình ảnh và tốc độ khung hình với

một hình lập phương sử dụng hiệu ứng bump (Hình 34).

5.1.2. Kết quả đánh giá

Với các thực nghiệm nêu ở trên, ta có các bảng đánh giá sau:

Thực nghiệm 1: Do OpenGL triển khai chiếu sáng trên vertex shader nên tốc độ khung hình cao hơn, nhưng chất lượng hình ảnh không mịn bằng triển khai trên fragment shader (Bảng 2). Đặc biệt, với nguồn sáng spotlight hướng vào trung tâm bàn

cờ, trong khi cả bốn đỉnh ở bốn góc của bàn cờ nằm ngoài vùng chiếu sáng – do vùng này nhỏ hơn kích thước bàn cờ, thì khung cảnh không được chiếu sáng với triển khai

OpenGL; như vậy, kết quả hình ảnh bị sai.

Bảng 2: Bảng đánh giá Thực nghiệm 1

Số nguồn sáng 1 2 3 4 5

224 217 209 192 184 Hệ thống Ánh sáng dùng OpenGL

204 179 169 153 138 Hệ thống ánh sáng tự định nghĩa

Thực nghiệm 2: Thực nghiệm này đánh giá khung cảnh gồm một bàn cờ có 32

quân, một nguồn sáng triển khai theo fragment shader. Với nguồn sáng thay đổi vị trí,

vùng đổ bóng SV được tính lại cho toàn bộ bàn cờ, nên tốc độ khung hình giảm đáng

kể.

Bảng 3: Bảng đánh giá Thực nghiệm 2

Nguồn sáng cố định Nguồn sáng thay đổi

Tốc độ khung 129 95 hình/giây

Thực nghiêm 3: Do không thiết kế được mô hình chi tiết tương ứng, nên thực

nghiệm này chỉ so sánh kết quả của một mô hình lập phương trơn có dán texture với

cùng mô hình lập phương đó sử dụng hiệu ứng bump.

Bảng 4: Bảng đánh giá Thực nghiệm 3

Số khung hình/giây Chất lượng hình ảnh

198 Không sử dụng bump

167 Sử dụng bump

5.2. Demo chương trình

Dưới đây là một số hình ảnh minh họa về một số khung cảnh 3D được xây dựng

từ GEM.

Hình 34: Hình hộp sử dụng hiệu ứng bump

Hình 35: Trò chơi cờ vua

Hình 36: Khung cảnh bên trong một ngôi nhà

KẾT LUẬN

Kết luận

Hệ thống Game Engine này cung cấp các giao diện để xây dựng được khung

cảnh 3D bao gồm các đối tượng, các hình ảnh và các nguồn sáng một cách tự động với

các tính năng mô hình hóa các đối tượng, hiệu ứng trong tự nhiên như nhân vật, nước,

lửa, khói, ánh sáng, địa hình... Người dùng dễ dàng dựng nên khung cảnh 3D không

phải quan tâm đến quá trình quản lý tài nguyên, cũng như quá trình xử lý đồ họa ở

mức thấp. Thay vào đó người dùng chỉ thiết kế sẵn các mô hình đối tượng và bố trí các

đối tượng này trong khung cảnh theo ý muốn.

Mô đun xử lý các hiệu ứng về ánh sáng và vật liệu cung cấp:

- Các mô hình tạo bóng khác nhau mà không phải thay đổi nhiều trong mã nguồn chương trình. Người dùng chỉ cần định nghĩa lại chương trình shader được viết bằng ngôn ngữ Cg.

- Tạo bóng cho các đối tượng trong khung cảnh 3D. - Hỗ trợ việc thiết kế đối tượng có bề mặt phức tạp, giảm không gian bộ nhớ

lưu trữ đối tượng.

Ngoài ra, với thiết kế theo hướng hướng đối tượng và có tính mở, người dùng có thể dễ dàng định nghĩa các lớp mới để biểu diễn các kiểu đối tượng mới bằng cách kế thừa từ những lớp đã có sẵn của hệ thống.

Bên cạnh những kết quả đã đạt được hệ thống vẫn còn tồn tại một số hạn chế.

Tốc độ xử lý đồ họa trong tính toán bóng còn thấp với các khung cảnh có nhiều chuyển động. Chưa triển khai đầy đủ các mô hình tạo bóng hiện có – mới chỉ triển

khai mô hình Phong và Lambert.

Hướng phát triển

Trong thời gian tới chúng tôi sẽ tiếp tục hoàn thiện hệ thống GEM theo hướng xây dựng các thành phần còn thiếu: âm thanh, vật lý và kiểm tra va chạm, và trí tuệ nhân tạo.

Với mô đun hiệu ứng ánh sáng và vật liệu này, tôi sẽ triển khai thêm nhiều mô hình tạo bóng mới (như Blinn, Fresnel), và các hiệu ứng ánh sáng khác như sương,

phản xạ. Bên cạnh đó, cũng cần phải tăng tốc độ xử lý trong tính toán bóng của vật thể với việc kết hợp các phương pháp tính đổ bóng khác.

PHỤ LỤC

A. Bảng thuật ngữ

Thuật ngữ Ý nghĩa

Ambient Thành phần phản xạ ánh sáng đối với ánh sáng đến từ mọi

hướng.

Bump Hiệu ứng sử dụng bản đồ pháp tuyến để tạo nên bề mặt lồi

lõm của vật thể.

Diffuse Thành phần phản xạ khuếch tán.

Height map Ảnh bitmap lưu thông tin về độ cao của từng pixel. Dùng để

tính vector pháp tuyến cho từng pixel dựa vào độ cao của nó

và các pixel xung quanh.

Quá trình chiếu sáng Lighting

Normal

Vectơ vuông góc với tiết diện của mặt bề mặt tại điểm P, dùng để tính toán yếu tố phản xạ ánh sáng của bề mặt.

Normal map

Ảnh bitmap lưu thông tin về vector pháp tuyến của từng pixel

Material

Định nghĩa nguyên liệu làm nên đối tượng, do đó quy định tính chất phản xạ ánh sáng của bề mặt đối tượng. Nguyên liệu gồm các thành phần màu ambient, diffuse, specular, độ bóng và màu nguyên thủy.

Mạng lưới đa giác là biểu diễn một mô hình vật thể. Mesh

Các mô hình đối tượng được dựng nên từ mạng lưới đa giác Model

Tính toán màu sắc bề mặt đối tượng hay còn gọi là tạo bóng Shader

Thành phần phản xạ gương. Specular

Ảnh bitmap được sử dụng để đắp lên bề mặt đối tượng. Texture

Điểm trong không gian 3 chiều. Vertex

B. Bảng biểu tượng

Biểu tượng Tên Ý nghĩa

Action Đặc tả một hành động

Aggregation Đặc tả quan hệ kết tập

Call message Đặc tả lời gọi, phương thức

Choice Đăc tả lựa chọn theo điều kiện

Class Đặc tả một lớp

Composition Đặc tả quan hệ hợp thành

Final state Đặc tả trạng thái kết thúc

Fork Đặc tả một giả trạng thái chia một trạng thái thành nhiểu trạng thái

Đặc tả quan hệ phụ thuộc Dependency

Đặc tả quan hệ tổng quán hóa Genaralization

Initial state Đặc tả trạng thái bắt đầu

Import Đặc tả quan hệ sử dụng

Join Đặc tả một giả trạng thái kết hợp nhiều trạng thái

Lifetime Đặc tả vòng đời của đối tượng

Note Đặc tả ghi chú

Merge Đặc tả quan hệ sắp trộn

Package Đặc tả một gói

State Đặc tả một trạng thái

Submachine State Đặc tả một trạng thái tham chiếu đến một hoặc nhiều trạng thái khác

TÀI LIỆU THAM KHẢO

[1]. Ulf Assarsson, Tomas Akenine-Möller. A Geometry-based Soft Shadow

Volume Algorithm using Graphics Hardware.

[2]. Ulf Assarsson, Michael Dougherty, Michael Mounier, Tomas Akenine-Möller. An Optimized Soft Shadow Volume Algorithm with Real-Time Performance. [3]. Hervé Brönnimann. Designing and implementing a general purpose halfedge

data structure.

[4]. Karel Driesen, Urs Hölzle. The Direct Cost of Virtual Function Calls in C++.

ACM 1995.

[5]. Steven Goodwin. Cross-Platform Game Programming. Charles River. 2005. [6]. NVIDIA Group. GPU Gems 1, 2, 3. [7]. NVIDIA Group. Cg tutorial. [8]. Khronos Group. OpenGL Specifcation Version 2.0. [9]. Jérôme JOUVIE. Lesson 8: Tangent Space. [10]. Jonathan Kreuzer. Object Space Normal Mapping with Skeletal Animation

Tutorial.

[11]. Dan Pilone, Neil Pitman. UML 2.0 in a Nutshell. O'Reilly. 2005. [12]. Richard S. Wright, Michael Sweet. OpenGL Super Bible.