1.    Deploy บนเครื่องจริง

2.    กับ ใช้ Android Virtual Device

ซึ่งทั้งสองทางเลือกนั้นต่างก็มีข้อเสีย ในขณะที่เครื่องจริงนั้นเราอาจจะไม่ได้อยากพกไปด้วย (เกะกะ) แถมต้องต่อสายมากมาย ส่วน AVD นั้นก็อืดอภิมหาอืด

หลังจากที่หาวิธี Debug ที่สะดวกกว่าการใช้อุปกรณ์จริง แต่ก็ทำได้งานได้เร็วพอที่จะใช้งานได้จริง (เพราะโน๊ตบุ๊คผมนั้นมันอืดเป็นปรกติอยู่แล้ว พอรัน AVD เข้าไปก็จะยิ่งอืดเข้าไปอีก) ก็พบว่ามีอีกวิธีนึงก็คือการรัน Android บน x86-based Virtual Machine โดยอาจจะเป็น VMWare หรือ Oracle VirtualBox หรืออื่น ๆ ก็ได้

ตัว AndroidOS นั้น จริง ๆ แล้วถูกออกแบบมาให้รันโดยไม่อ้างอิงกับสถาปัตยกรรมของระบบที่รันอยู่อยู่แล้ว แต่เนื่องจากว่าอุปกรณ์ที่เป็น Android ส่วนใหญ่นั้นจะทำงานอยู่บนสถาปัตยกรรมของ ARM ดังนั้นการที่จะเอามาทำงานบน x86 ก็มีความท้าทายอยู่ในระดับนึง โชคดีที่เรามีคนที่กำลังทำงานอยู่กับมันอยู่แล้ว นั่นก็คือโครงการ Android-x86

เราสามารถเอา iso จากเวปไซท์ Android-x86 มาติดตั้งลงบน Virtual Machine ได้เลย แต่ว่า ปัญหาคือ Android นั้นออกแบบมาสำหรับโทรศัพท์มือถือ/แท๊บเบล็ต และ โทรศัพท์มือถือเกือบทั้งหมดไม่มีพอร์ท Ethernet ซึ่ง VM ส่วนใหญ่จะใช้พอร์ทนี้ในการเชื่อมต่อกับเครื่อง Host ดังนั้นเราจึง Debug ไม่ได้… สำหรับ Android-x86 นั้นมีการเพิ่มส่วนการรองรับ Ethernet เข้ามาก็จริง แต่ก็ยังไม่รองรับ Android 3 (Honeycomb) และ Android 4.0 (Ice Cream Sandwich)

แต่เรายังมีความหวังอีกทาง เมื่อมีอีกหน่อนึงพยายามที่จะทำให้ Android AOSP นั้นทำงานได้บน Oracle VirtualBox หนุ่มรายนี้ชื่อนาย Dan แห่งเวป BuilDroid ซึ่งเจ้าหนุ่มคนนี้นั้นสามารถทำให้ Android 4 AOSP นั้นสามารถรันบน VirtualBox ได้แล้ว (แต่ยังไม่สมบูรณ์) ส่วนตัวผมยังคงโชคร้าย หลังจากที่ลองดาวน์โหลดมาใช้แล้วก็พบว่าเกิด Kernel Panic ระหว่างการบูท สันนิษฐานว่าผมใช้ เครื่องที่ใช้ CPU AMD ซึ่งไม่เหมือนชาวบ้านเขา

เหมือนความหวังทั้งสองด้านจะมืดไป แต่เดี๋ยวก่อน นาย Dan ได้สร้างของอีกอย่างขึ้นมา นั่นคือ เขานำเอา Android-x86 มารวมกับ Patch ที่เขาเขียนขึ้นมา และ ไอ้ Patch ตัวนี้นั้นมันสามารถใช้งานบนเครื่องผมได้ล่ะ !! คุณสามารถเอามาลองได้จากหน้านี้ครับ

ติดตั้ง Android 4.0 บน VirtualBox

ก็เริ่มจาก ดาวน์โหลดไฟล์ iso จากลิงค์ข้างบนมาก่อนนะครับ

ต่อจากนั้นก็เปิด Oracle VirtualBox ขึ้นมา เลือก New ที่ทูลบาร์ด้านบนเพื่อที่จะสร้าง VM ใหม่ครับ

ก็จะขึ้น Wizard ดังรูป คลิ๊ก Next ไป

ต่อไป ใส่ชื่อ ตามด้วย เลือก OS Type เป็น Linux และ Version Other Linux ครับ

ต่อไปก็ กำหนดขนาดของหน่วยความจำหลัก เครื่องโน๊ตบุ๊คผมมันแรมน้อยครับ ดังนั้นก็เลยต้องเลือกน้อยหน่อย ผมคิดว่าขั้นต่ำควรจะ 512MB แต่อันนี้ไม่เคยลองต่ำกว่านี้เหมือนกัน

ต่อไปก็คือ Hard Disk อันนี้แล้วแต่สะดวกเหมือนกัน ผมเลือกที่จะสร้างใหม่ โดยจะใช้ขนาด 8GB ครับ (เอาเข้าจริง ๆ ใช้ไม่ถึงหรอกครับ อันนี้แค่เผื่อเฉย ๆ)

พอเลือกที่จะสร้างจะขึ้น Wizard สำหรับสร้าง Disk ใหม่ ตรงนี้ตามสะดวกครับ

เลือกเป็น Dynamic Allocation จะได้ประหยัดพื้นที่ HDD ครับ

ใส่ชื่อและเลือกขนาด ผมเลือกเป็น 8GB แต่จริง ๆ แล้วตัว Android X86 เองจริง ๆ น่าจะกินที่ไม่เกิน 1GB ครับ อันนี้เผื่อไว้เฉย ๆ

ถึงตรงนี้ Disk ก็จะถูกสร้างละ

สุดท้าย VM ก็จะถูกสร้างครับ คลิ๊ก Create ไปเลย

ทีนี้ก็จะเห็น VM ตัวใหม่ขึ้นมาแล้ว (ผมให้ชื่อว่า Android 4 x86) แต่ยังครับ อย่าเพิ่งกด Start กดไปตอนนี้ก็ไม่ได้อะไรขึ้นมาครับ

ขั้นต่อไปจะเริ่มการตั้งค่า VM ล่ะครับ เลือก Settings เลยครับ จะขึ้นหน้าจอแบบนี้

เลือก System จะเห็นว่า หน้า Enable absolute point device จะถูกติ๊กอยู่ ตรงนี้ต้องเอาออกครับ ไม่เช่นนั้นพอเปิด Android ขึ้นมา ตัว Pointer จะไม่แสดงขึ้นมา ทีนี้จะหาไม่เจอครับว่าเมาส์อยู่ตรงไหน 555

ต่อไป เลือก Storage คลิ๊กตรงไอคอนรูป CD ที่เขียนว่า Empty แล้วกดปุ่มรูป CD ด้านขวา

แล้วเลือก iso ไฟล์ที่ดาวน์โหลดมาครับ (ไม่มีรูปเพราะไม่ได้ลงโปรแกรม capture ดีๆ ไว้ 555) ก็จะออกมาแบบนี้ครับ

สุดท้าย ตรงหน้า Network เลือก Attached to : Host-only Adapter ตรงนี้จริง ๆ สามารถเลือกเป็นแบบอื่นก็ได้ ขอแค่ให้เครื่องเราเห็น VM และตัว VM จะต้องถูกแจก IP ด้วย DHCP (ซึ่งในโหมด Host-Only จะแจก IP ให้ครับ) แต่ในตอนนี้เอาเป็นอันนี้ก่อนครับเพื่อความสะดวก

เสร็จก็กด OK ปิดได้เลยครับ

ทีนี้เราจะเริ่มติดตั้ง VM จริง ๆ กันละ กด Start ได้เลย

พอเริ่มแล้ว ก็รอนิดนึง มันจะบูทครับ ก็จะเข้าหน้า Boot Loader ก็เลือก Installation

รออีกนิด มันจะมีตัวหนังสือมากมาย แล้วจะเข้ามาหน้านี้ เป็นการสร้าง Partition บน Disk ครับ เลือก Create/Modify partitions

ก็เข้าหน้าสร้าง Partition เลือก New เลยครับ

เลือกเป็น Primary Partition นะครับ (จริง ๆ คิดว่าไม่เกี่ยว แต่เลือกไปเถอะ)

ใส่ขนาด ผมก็ใส่เต็มไปเลยนี่ล่ะ ง่ายดี

ถึงตรงนี้ เราเลือกที่จะสร้าง partition แล้ว (แต่ถึงขั้นนี้ยังไม่ได้สร้างจริง ๆ ครับ) ต่อไปเลือก Boot เพื่อให้ partition นี้มันบูทได้ (อันนีก็คิดว่าไม่เกี่ยว แต่ใส่ไปเถอะ)

เลือกพาร์ทิชั่น (ซึ่งมีอันเดียว)

ต่อไปเลือก Write เพื่อที่จะบันทึกสิ่งที่เราทำมาทั้งหมดลงไป ถ้าเราไม่กด Write ก่อนออกจากหน้านี้ ก็จะไม่มีอะไรเกิดขึ้นครับ (ที่ทำมาหมดก็หายหมด)

ยืนยันเสียหน่อย พิมพ์ yes แล้วกด enter

สุดท้ายเลือก quit เพื่อออก

ต่อไปก็เลือก partition ที่เราเพิ่งสร้างเสร็จครับ เราจะติดตั้ง android ลง partition นี้แหละ

ตัวติดตั้งจะฟอร์แมท partition ของเรา ก็เลือกเป็นอันไหนก็ได้ครับแล้วแต่ชอบ แต่ผมเลือก ext3 นะ (อันอื่นไม่เคยลอง)

ยืนยันอีกสักที

เริ่มฟอร์แมทละ

ต่อไปจะติดตั้งตัว Boot Loader (ถ้าไม่มีจะบูทไม่ได้) ตอบ Yes ไปเลย

อันนี้จะถามว่า จะทำให้ /system นั้นเขียนได้มั้ย ผมคิดว่าเราไม่จำเป็นต้องไปปกป้องอะไรมัน (ถ้าพังก็ลงใหม่) ดังนั้นทำให้มันเขียนได้จะมีประโยชน์มากกว่าครับ (โดยเฉพาะตอนที่พยายามจะติดตั้ง GAPP)

ติดตั้ง Android 4 อย่างรวดเร็ว

อันนี้จริง ๆ คือติดตั้งเสร็จละ แต่ว่า … สร้างตัว Fake SD Card ไปเลยดีกว่า เจ้านี่จะทำตัวเหมือนเป็น SD Card ครับ ถ้าโปรแกรมที่เราจะดีบั๊กใช้ SD Card เราก็ควรจะ Enable ไว้ จะทำให้ชีวิตง่ายขึ้นครับ

ค่าที่ให้มาคือขนาดที่ใหญ่ที่สุดที่สร้างได้ (2GB) ก็ Enter ไปเลย

เริ่มสร้างละครับ ตรงนี้รอนานหน่อย

เมื่อสร้างเสร็จแล้วมันจะบังคับให้รีบูทครับ ก็กด Enter ไป

แต่เอ่อ ถ้าเรารีบูททั้งอย่างนี้ … มันจะบูทกลับไปที่ DVD ตัวติดตั้งน่ะครับ … ดังนั้นเราต้อง Reject ตัว DVD ออกก่อน

จากนั้นก็ reboot ใหม่

ของจริงมาแล้ว เลือกอันบนโลดครับ (ถ้าไม่เลือกภายใน 5 วินาทีมันก็จะเลือกอันบนสุดให้อยู่ดี)

เข้า Android Boot Loader ละครับ เย้

ก็เป็นอันเข้าได้เรียบร้อยแล้วครับ เป็น Android 4.0.3 นะครับ

เริ่มใช้ Eclipse กับ VM ที่เพิ่งสร้างเสร็จ

ต่อไปก็เริ่มดีบั๊กกันจริงจังละครับ เริ่มจากเลือก Terminal ขึ้นมาก่อน

ที่ Terminal พิมพ์คำสั่ง netcfg จะเห็นว่ามี interface ที่ UP อยู่สองตัว ตัวแรกคือ lo หรือ loop back ซึ่งเราไม่ใช้ อีกตัวก็คือ eth0 จดเลข IP เอาไว้นะครับ

ต่อไป กลับไปที่ host เปิด command prompt ขึ้นมา (บน Windows ก็เปิด Command Prompt บน Mac/Linux ใช้ Terminal) เข้าไปยัง Folder ที่เก็บตัว Android SDK ไว้นะครับ

แล้วเข้า folder ที่ชื่อว่า platform-tools

พิมพ์คำสั่ง adb connect <เลขไอพีที่จดไว้> ดังนี้ครับ

เมื่อต่อได้สำเร็จจะขึ้นข้อความข้างล่าง ถือว่าประสพความสำเร็จเรียบร้อย ปิด command prompt/terminal ได้เลยครับ

ต่อไปก็ไปที่ Eclipse ใครที่ยังไม่เปิดก็เปิดซะนะครับ ตอนรันโปรแกรม ที่หน้าจอ Android Device Chooser จะปรากฎของเครื่อง VM ที่เราเพิ่ง connect เข้าไป แบบนี้ครับ

ก็เลือกซะแล้วกด OK แล้วโปรแกรมเราก็จะรันขึ้นมาได้แบบนี้ครับ

แค่นี้ก็รันได้ Debug ได้แล้วล่ะครับ

อ้างอิง : Nuxeo Developers Blog, Android-x86, Buildroid

ก็มีคนมาท้วงว่า เฮ้ย คำนี้มันควรเขียนว่า ดิจิทัล ตามที่ Glossary เขียนไว้สิ

เท่านั้นแหละก็มีคนมาสาธยายความยาวว่า ไอ้คำว่า ดิจิทัลเนี่ย มันไม่ถูกนะ อย่างโง้นอย่างงี้ แล้วทำไมเราต้องไปใช้คำนี้ตามที่ “ราชบัณฑิต” บัญญัติเอาไว้ด้วย แล้วก็เริ่มลากไปไหนก็ไม่รู้ ไปเรื่องกฎหมายบ้าง

เค้าบอกว่า “คนอื่นก็เรียกว่า ‘ดิจิตอล’ ทั่วบ้านทั่วเมือง ทำไมราชบัณฑิตถึงบัญญัติคำนี้ว่า ‘ดิจิทัล’ มันไม่ถูกนะ” ก็ว่าไปเรื่อย แล้วก็บอกว่า ฝรั่งเองก็ออกเสียงคำนี้ว่า ‘ดิจิตอล’ เหมือนกัน

มันผิดตั้งแต่ ต้อน แล้วคุณ ภาษาอังกฤษมันมีเสียง ต ที่ไหน ?

ถ้าลองไปค้นหาคำนี้ในพจนานุกรมภาษาอังกฤษที่เป็นแบบ Advanced Learner มันจะระบุวิธีการออกเสียงของแต่ละคำเอาไว้ด้วยสัญลักษณ์ที่เรียกว่า Phonetic ซึ่งสำหรับคำว่า Digital เนี่ยมันจะเขียนว่า ˈdɪdʒɪtl (อ้างอิงจาก Oxford Advanced Learners Dictionary) สำหรับคุณ ๆ ที่อ่านไม่ออก ไม่ต้องตกใจ ผมก็ลืมหมดแล้ว (เคยเรียนคอร์สการออกเสียงอยู่ครั้งหนึ่ง ซึ่งเป็นเรื่องของ Phonetic ล้วน ๆ มันเป็นอะไรที่ถ้าเรียนแล้วไม่ค่อยได้ใช้ก็ลืมเกลี้ยง) แต่จะเทียบเคียงจากเสียง ดิจิตอล ก็แล้วกัน

เอาคำที่ออกเสียงชัด ๆ ว่า ทอล (ตอลนี่ ไม่มีแน่ ๆ ) นะครับ คำว่า Tall มี Phonetic คือ tɔːl ลองสังเกตว่ามันเขียนไม่เหมือนคำข้างบนนะครับ

คือไอ้ตัว tal มันไม่ได้ออกเสียงยาว ๆ แต่เป็นการรวบเสียงให้สั้น การที่ใช้ไม้หันอากาศซึ่งแสดงว่าเป็นการออกเสียงสั้น ผมว่ามันก็เหมาะสมดีแล้ว (แล้วอย่าลืม Stress ตัวหน้าสุดนะ)

แต่ประเด็นมันไม่ได้อยู่ที่ความถูกต้อง หลักภาษามันเป็นเรื่องของความนิยม ถ้ามันนิยมมันก็ใช้ได้ ไม่ค่อยมีกฎตายตัวเท่าไหร่ ไอ้ที่ทำให้ผมเซ็งเนี่ยมันคือการที่บอกว่า มันมีอันนึงถูก อันนึงผิด

ความเห็นผม มันก็ถูกทั้งคู่แหละ อันนึงถูกเพราะว่าเป็นหลักภาษา (คำทับศัพท์ภาษาไทยจะใช้การสร้างคำจากเสียงของคำจากภาษาต้นฉบับ) อีกอันมันก็ถูก เพราะคนใช้เยอะ (แปลได้อีกอย่างว่า พวกมากลากไป) เรียกได้ว่านิยม ว่างั้นแหละ

เรื่องภาษาผมไม่ซีเรียส มีปราชญ์ท่านนึงว่าไว้ว่า ภาษามันเหมือนสิ่งมีชิวิต มันมีการคัดเลือกทางธรรมชาติ คำที่ไม่มีคนใช้มันก็หายไปทุกวัน ๆ และก็มีคำใหม่เกิดขึ้นทุกวัน ผมมองว่าการใช้สิ่งที่ถูกต้องในชีวิตประจำวันก็เป็นการรักษาให้มันคงอยู่ แต่สำหรับไอ้ที่ผิดแต่นิยมก็ใช้ไปไม่ได้ซีเรียสอะไร ไม่งั้นก็โดนว่าว่าพูดไม่รู้เรื่อง (หรืออย่างกรณีคำนี้ก็อาจจะโดนว่าว่ากระแดะ พูดภาษาไทยคำ อังกฤษคำ ได้เหมือนกัน)

แต่เพราะไอ้ความคิดว่า เพราะมีคนทำเยอะ มันก็เลยถูกนี่ล่ะ มันเลยทำให้บ้านเมืองเดือดร้อนมาจนถึงทุกวันนี้ ทุกวันนี้เรามีคนที่ขายของบนทางเท้า มีแท๊กซี่ที่ไม่รับผู้โดยสาร มีมอไซค์วิ่งบนฟุตบาท (<- คำนี้ก็ผิดแต่ใช้กันเพราะนิยม คำต้นฉบับคือ Foot Path ฟุตพาธ น่ะล่ะ) แล้วพอมีคนโวยวายว่ามันไม่ถูกก็จะโดนตอกกลับไปว่ามันจะไม่ถูกได้ยังไงเพราะเขาทำกันทั่วบ้านทั่วเมือง ไอ้คนที่ไม่ทำนี่แหละผิด …

ถ้าคิดแบบนี้ไม่ต้องไปเลือกตั้งหรอกครับ เลือกคนเข้าไปตรากฎหมายทำไม มีกฎหมายไปท่านก็ไม่ทำอยู่ดี อ้างว่า เพราะทำกันมาทั่วบ้านทั่วเมืองแล้วมันจะผิดได้ยังไง ใช่หรือไม่ !

หงุดหงิดจริง …

ภาพข้างบนผมจับมาจากเกมที่ชื่อว่า Lufia II : Sin of Sinistral ซึ่งเป็นภาคแปลจากเกมที่ชื่อว่า Espolis Biography II … เกมนี้เป็นเกมที่ผมชอบมากเมื่อสมัยเด็ก ๆ เพราะเป็นเกมที่ต้องใช้ความคิดในการแก้ปริศนาเยอะมาก (ยากด้วย) ปัจจุบันมีการ Remake เกมนี้ขึ้นมาใหม่ กลายเป็น Lufia ภาคแรกไป (เพราะเนื้อเรื่องภาคนี้จะอยู่ก่อนหน้าอีกภาคนึง) ซึ่งไม่สนุกเหมือนตัวเก่า แต่ก็ออกมาแล้วหายคิดถึงไปเยอะเลย

นอกเรื่องมาไกล อยากให้สังเกตความเป็น Tile ของเกมน่ะครับ สำหรับเครื่องเกมในอดีต ถ้าเป็นของ Nintendo ก็นับตั้งแต่ Famicom ขึ้นมา ยันเครื่อง DS จะเป็นเครื่องที่รองรับการทำ Tile ในระดับฮาร์ดแวร์ ซึ่งทางนินเทนโดเองจะเรียกว่า Character ที่เรียกแบบนี้ก็เพราะจริง ๆ แล้วเรากำลังเขียนเกมอยู่บน Text Mode ที่สวยขึ้นมาอีกหน่อยเท่านั้นเอง

ที่ว่าเป็น Tile Base System ตั้งแต่ระดับ Hardware ก็คือตัว Hardware จะมีหน่วยความจำพิเศษสำหรับเก็บข้อมูล Tile และหน่วยความจำพิเศษอีกส่วนนึงที่เก็บข้อมูลกราฟิคบนจอ โดยจะเก็บเป็น aray ของ index ของ Tile ดังนั้นเราจะไม่มีทางที่จะวาดภาพบนจอภาพแบบระบุพิกัดเป็น Pixel ได้ นั่นคือที่มาว่าทำไมเกมสมัยก่อนจึงเป็นตารางครับ

กลับมาเข้าเรื่องของเรากัน จากภาพข้างบนเราจะเห็นว่ามีการแสดงผลข้อความที่เขียนว่า “Ta-daaa! It’s fish pot pie made of ‘navaroa’, the phantom fish!” นะครับ ผมคิดว่าคุณอาจจะคิดว่าข้อความนี้เก็บข้อมูลเป็นระหัส ASCII ซึ่งผมยืนยันได้เลยว่า “ไม่ใช่”

ในระบบแบบ Tile-base เนี่ย เราจะมองว่า ช่องไหนใช้ tile index ที่เท่าไหร่ การที่จะต้องเสียพื้นที่เก็บข้อมูลสำหรับ Tile โดยใช้ ASCII Code เนี่ย ไม่ Efficient เพราะว่า ASCII Code มีโค๊ดบางส่วนที่ไม่มีการแสดงผล การที่จะต้องเก็บข้อมูลว่าง ๆ ลงไปใน Tileset นั้นทำให้เสียพื้นที่ที่น้อยนิดไปอย่างฟรี ๆ ดังนั้น Encoding ที่ใช้นั้นจะเป็น Encoding ที่สร้างขึ้นมาใหม่ครับ (ผมเข้าใจว่ามี Tool ที่มาช่วยตรงนี้อยู่แล้ว)

อีกอย่างนึง อยากให้ดูโครงสร้างการเก็บข้อมูลหน้าจอของอุปกรณ์ประเภทนี้ สมมติว่า บัฟเฟอร์การแสดงผลของเรานั้นสามารถแสดงผลได้ 64*64 tile บนหน้าจอ มันจะเก็บข้อมูลแบบนี้ครับ

BYTE dispBuffer[64*64]; // 4096 tile

นั่นก็คือ ถ้าเราต้องการจะวาดตัวหนังสือให้อยู่ตรงกลาง เราจำเป็นจะต้องใส่รหัสพิเศษระหว่างตัวอักษรเพื่อจัดตำแหน่งให้ตัวหนังสือมันมาอยู่ตรงกลาง ในตำแหน่งที่เราต้องการด้วย

และสุดท้ายสังเกตตัวอักษรให้ดี ๆ นะครับ

สังเกตมั้ยว่าด้านสูงกับด้านกว้างของตัวอักษรไม่เท่ากัน จริง ๆ แล้วในแต่ละตัวอักษรมันเป็นสอง Tile ประกบกันบนล่างครับ

วิธีการใช้การประกบบนล่างแบบนี้จริง ๆ ก็มีข้อดีอย่างนึงคือ บาง Tile ก็ประหยัดได้ อย่าง ตัว i กับตัว j เนี่ย มันจะต่างกันแค่ด้านล่างใช่มั้ยครับ ถ้าด้านบนใช้ tile เดียวกัน ก็ประหยัดไปได้ 1 tile (ตัว h กับ n ก็ได้อีกคู่นะ)

และถ้าจะทำจริง ๆ เราสามารถทำให้บางตัวอักษรกว้างสองช่องก็ทำได้ครับ แต่พอดีผมหาตัวอย่างไม่เจอน่ะ

วันนี้พูดแค่ผ่าน ๆ ก็คงพอ เพราะว่าเราคงไม่ได้ใช้ tile-base แท้ ๆ กันสักเท่าไหร่แล้ว คราวต่อไปจะพูดถึงการวาดตัวอักษรแบบที่เป็น raster จริง ๆ แล้วครับ

เราสามารถแบ่งประเภทของ Font ได้จากลักษณะของ Glyph ที่มันเก็บเอาไว้ได้สองลักษณะ ดังนี้

1. Raster Font

Raster Font ก็คือ Font ที่เก็บ Glyph ในลักษณะของ Raster … ก็คือ … Bitmap น่ะล่ะครับ

Font ในยุคต้น ๆ จะเป็น Raster ทั้งหมด เพราะว่าเครื่อง PC ในสมัยนั้นมีความสามารถต่ำ และ คนที่สร้างฟอนท์เองก็ไม่ได้เก่งอะไร (อย่าลืมว่าคอมพิวเตอร์ในยุคแรก ๆ นั้นผู้ใช้เป็นคนที่อยู่ในวงการคอมพิวเตอร์ และคณิตศาสตร์ เสียส่วนใหญ่นะครับ) การวาดฟอนท์ด้วยภาพ Bitmap นั้นไม่ได้ยากมาก แต่อาจจะดูไม่สวยอยู่สักหน่อย

2. Vector Font

Vector Font ก็คือ Font ที่เก็บข้อมูล Glyph ในแบบ Vector (กำปั้นทุบดินจริง ๆ ) เหมือนภาพใน Illustrator หรือ Corel Draw นั่นล่ะครับ

ในยุคหลัง ๆ มีความพยายามจากทางวงการสิ่งพิมพ์ว่า เขาอยากได้ฟอนท์ที่สามารถย่อ-ขยายได้ โดยที่ตัวหนังสือยังคงดูคมชัดเหมือนเดิม ก็เลยมีคนสร้างฟอนท์ที่ใช้ภาพ Vector ขึ้นมา เพราะสามารถยืดขยายได้ตามใจชอบ เรียกได้ว่าเป็นฟอนท์ที่มีความยืดหยุ่นสูงนั่นเอง

Raster vs Vector

มาดูข้อดีข้อเสียของฟอนท์แต่ละประเภทกันดีกว่า

1. ความยืดหยุ่น

• Vector Font จะได้เปรียบในข้อที่ว่า ตัว Glyph สามารถยืดขยายได้โดยที่ไม่เสียคุณภาพภาพมากนัก
• ในขณะที่ถ้าเป็น Raster Font พอยืดขยายแล้วในบางครั้ง Glyph อาจจะเละจนอ่านไม่ออกไปเลยก็มี

2. ความยากง่ายในการใช้งาน

• Raster Font นั้น เก็บข้อมูลในรูปของภาพ Bitmap ซึ่ง การแสดงผลบนหน้าจอของคอมพิวเตอร์ในปัจจุบันก็เป็นภาพ Bitmap ทั้งหมด ดังนั้นเราจึงสามารถวาด Glyph ลงไปได้ตรง ๆ โดยที่ไม่ต้องมีการแปลงข้อมูล
• Vector Font นั้น เก็บช้อมูลในรูปของชุดคำสั่งการวาดภาพ ดังนั้นเราต้องนำชุดคำสั่งนี้ไปประมวลผลก่อน (เรียกว่าการทำ Rasterization) เพื่อสร้างภาพ Bitmap ก่อนที่จะนำภาพนั้นขึ้นไปวาดบนจอ

แล้วเราจะใช้ Font แบบไหนดี ในเกมของเรา

ในเกมคอนโซลยุคเก่า ๆ Font จะเป็น Raster Font ทั้งหมด เพราะว่าเกมคอนโซลนั้นจะทำงานอยู่บนอุปกรณ์ที่มีความละเอียดคงที่ เช่น 640×480, 256×198 เป็นต้น ดังนั้นจึงไม่จำเป็นที่จะต้องใช้ฟอนท์ที่ย่อ/ขยายขนาดได้ รวมทั้งการทำ Rasterization ก็เป็นกระบวนการที่มีความซับซ้อนสูง และกินเวลาในการคำนวนค่อนข้างนานอีกด้วย

สำหรับเกมคอนโซลในยุคใหม่ ๆ อย่าง XBox 360 หรือ Playstatin 3 และเกม PC มักจะใช้ Vector Font เพราะว่าตัวระบบปฎิบัติการณ์ของแต่ละเครื่องรองรับการวาดภาพตัวอักษรด้วยฟอนท์ประเภทนี้อยู่แล้ว

แต่โดยส่วนตัวผมยังคิดว่า การวาดตัวอักษรด้วยฟอนท์แบบ Raster นั้นเหมาะสมกับเกมมากกว่า เพราะผู้ใช้แทบไม่มีความจำเป็นจะต้องควบคุมขนาดของตัวอักษรเลย และในความเป็นจริงเกมของเราก็ยังคงทำงานอยู่บนหน้าจอที่มีความละเอียดคงที่ (อาจจะรองรับแค่ 480i + 720p ก็พอ) หรือแม้ว่าเราจะอนุญาตให้ผู้ใช้ปรับแต่งความละเอียดเองได้ เราก็ยังคงสามารถจะ scale ภาพ Glyph ให้เล็กหรือใหญ่ขึ้นตามความละเอียดของหน้าจอได้อยู่ดี (แน่นอนว่าต้องแลกกับคุณภาพของภาพที่ได้ครับ)

บทนี้จะพูดถึงเรื่อง Technical ล้วน ๆ ครับ ใครอยู่สายอื่นอาจจะไม่ต้องทำความเข่้าใจมันมากก็ได้ อันที่จริงมันไม่ค่อยมีประโยชน์ต่อคนในสาย Artist/Designer เท่าไหร่หรอก

String

ก่อนจะเข้าเรื่องการเข้ารหัส จะขอพูดถึง String ก่อน String ก็คือ สายอักขระ … สายของตัวอักษรนั่นล่ะ จริง ๆ ก็คือ ชุดของตัวอักษรที่เรียงต่อกันเป็นแนวยาว

ผมเองก็ไม่รู้ว่าทำไมต้องคิดมากขนาดนั้น เพราะจริง ๆ เราก็เขียนหนังสือเป็นแนวเดียว (ไม่ขวางก็ตั้ง) และในทิศทางเดียว แต่ก็นั่นล่ะคำคำนี้เป็นสิ่งที่วิศวกร/นักวิทยาศาสตร์ในอดีตเป็นคนบัญญัติขึ้น จะไม่เอามาใช้ก็เห็นจะแปลกไปนิด

ลักษณะพิเศษของ String ก็คือ มันเป็นข้อมูลแบบ Stream ที่ไหลไปทางเดียวกันตลอด จะสังเกตได้ว่าเวลาเราอ่านตัวหนังสือเราจะไม่ค่อยมีการอ่านย้อนกลับมากนัก (การอ่านข้อมูลในทิศทางเดียวเป็นลักษณะเฉพาะของ Stream) ดังนั้นเราจะมองว่า String คือ Stream ของ Character ก็ได้เหมือนกัน

Fixed-Length Character Encoding (การเข้ารหัสโดยใช้รหัสที่มีจำนวนหลักตายตัว)

การเข้ารหัสในลักษณะนี้จะเป็นการแทนที่ตัวอักษรใด ๆ ด้วยตัวเลขที่มีจำนวนหลัก (digit) แบบคงที่ เช่น การเข้่ารหัสด้วยตัวเลข 8หลัก (8บิท) 16หลัก หรือ 32 หลัก

ที่ผมพูดถึง ตัวเลขในที่นี้ หมายถึงเลขฐานสองนะครับ เพราะคอมพิวเตอร์คำนวนโดยใช้เลขฐานสอง และจำนวนหลักที่ว่านี้ก็คือจำนวนหลักของเลขฐานสองนั่นเอง

ASCII และ Extended ASCII

ASCII เป็น การเข้ารหัสโดยใช้รหัสแบบ 8 บิท (หรือ 1ไบท์) โดยที่หลักสุดท้ายนั้นจะเป็น 0 เสมอ
โดยเราจะนับหลักหน่วย (หลักขวาสุด) เป็นหลักแรกนะครับ ดังนั้นจะมีจำนวนรหัสที่เป็นไปได้ทั้งหมดที่ 128 รหัส (ก็คือ 0-127 นั่นเอง) ASCII เป็นมาตรฐานที่รวบรวมเอาตัวอักษรและสัญลักษณ์ในภาษาอังกฤษ ซึ่งรวมถึงรหัสอักขระพิเศษที่ไม่ได้ใช้แสดงผลเอาไว้ด้วย (รหัสอักขระพิเศษ คือรหัสอักขระที่มีหน้าที่พิเศษ เช่น ตัดบรรทัด ขึ้นย่อหน้าใหม่ เป็นต้น เป็นอักขระที่ไม่ได้ใช้ในการแสดงผลครับ) ASCII เป็นมาตรฐานแรก ๆ ในโลกที่ยังคงใช้จนถึงปัจจุบันนี้ครับ

Extended ASCII เป็นการเพิ่มเติมส่วนขยายให้แก่ ASCII โดยจะมีการใช้ 1 บิทสุดท้าย (ที่ไม่ได้ใช้ใน ASCII) เพื่อเพิ่มจำนวนรหัสให้มากขึ้นเป็น 256 รหัส เพื่อที่จะเพิ่มรหัสสำหรับตัวอักษรที่ไม่ได้ใช้ในภาษาอังกฤษนั่นเองครับ

ตัวอย่างสำหรับมาตรฐาน Extended ASCII ก็เช่น ISO8859-1 (ชุดตัวอักษรลาติน) TIS620 (ชุดตัวอักษรภาษาไทย) เป็นต้น

UTF-16

UTF-16 เป็นมาตรฐานการเข้ารหัสที่กำหนดโดย Unicode เป็นการเข้ารหัสโดยการใช้รหัสตัวเลขที่ยาวถึง 16 หลัก (16บิท หรือ 2 ไบท์) ทำให้สามารถรองรับจำนวนรหัสได้ถึง 65,532 รหัสครับ ที่ต้องมากถึงขนาดนี้เพราะว่า Unicode เป็นมาตรฐานที่รวมเอารหัสของตัวอักษรในภาษาหลัก ๆ ที่ใช้กันในโลกนี้เอาไว้นั่นเอง

UTF-16 สามารถแบ่งย่อย ๆ ได้ตาม Endian ของมัน ก็คือ Big Endian และ Little Endian UTF16 แบบ Little Endian จะเรียกว่า UTF-16le ครับ ท่านที่่ไม่รู้ว่า endian คืออะไร ก็ขอความกรุณาศึกษาเพิ่มเติมเอาเองนะครับ

Variable-Length Character Encodeing (การเข้ารหัสโดยใช้รหัสที่มีจำนวนหลักไม่คงที่)

อันนี้ก็จะตรงกันข้าม ก็คือ รหัสแต่ละตัวอาจจะสั้นยาวไม่เท่ากัน ตามแต่ผู้ออกแบบกำหนด โดยส่วนใหญ่จะใช้วิธีกำหนดช่วงเอาไว้ว่า รหัสในช่วงใดช่วงนึงจะมีความยาวที่ระดับนึง ในขณะที่ในอีกช่วงนึงก็จะมีความยาวที่อีกระดับนึง เช่น ตัวอักษร 128 ตัวแรก ใช้รหัสที่ยาว 8 หลัก (8บิท หรือ 1 ไบท์) ในขณะที่ตัวที่เหลือจะใช้ความยาวที่ 16 หลัก (16 บิท หรือ 2 ไบท์) เป็นต้น

การเข้ารหัสแบบนี้เกิดขึ้นในสมัยที่หน่วยความจำยังมีราคาแพง แต่ จำนวนตัวอักษรที่ Extended ASCII รองรับนั้นไม่เพียงพอต่อการใช้งานในบางภาษ เช่น ในภาษาจีนมีอักขระที่แตกต่างกันเป็นหมื่นตัว ภาษาญี่ปุ่นที่มีชุดอักขระมากถึงสามชุด เป็นต้น แต่การที่จะไปใช้การเข้ารหัสแบบ 16 บิทนั้นใช้หน่วยความจำมาถึง 2 เท่าของปรกติ และ ซอฟท์แวร์ที่ใช้จะเข้ากับซอฟท์ดั้งเดิมที่ใช้การเข้ารหัสแบบ 8 บิทไม่ได้ จึงมีการพัฒนาการเข้ารหัสแบบนี้ขึ้นมาครับ

สามภาษาที่เป็นต้นเหตุของการเข้ารหัสแบบนี้นั้น เป็นประเทศในเอเซียตะวันออกทั้งหมดเลย นั่นคือ จีน ญี่ปุ่น และเกาหลี เราจะเรียกกลุ่มเประเทศเรื่องมากพวกนี้ว่า กลุ่ม CJK ครับ

ตัวอย่างของการเข้ารหัสแบบนี้ก็คือ BIG5 (Chinese), Shift-JIS(Japanese), EUC-KR (Korean) เป็นต้น ผมจะไม่พูดถึงรายละเอียดนะครับ แต่ลองค้นคว้ากันดูก็ได้นะ

UTF-8

UTF-8 เป็นการเข้ารหัสที่กำหนดโดย UNICODE เช่นเดียวกับ UTF-16 โดยการเข้ารหัสแบบนี้จะใช้รหัสที่สั้นที่สุดที่ 8 บิท (1ไบท์) จนถึงยาวที่สุดที่ 4ไบท์ โดยตัวที่จะบอกว่ารหัสนั้นยาวแค่ไหนก็คือบิทสุดท้ายของไบท์แรกที่อ่านครับ

• ถ้าหลักสุดท้ายของไบท์แรก คือ 0 รหัสนี้จะยาว 8บิท
• ถ้า 3 หลักสุดท้ายของไบท์แรก คือ 110 รหัสนี้จะยาว 16บิท
• ถ้า 4 หลักสุดท้ายของไบท์แรก คือ 1110 รหัสนี้จะยาว 32บิท

โดยเราจะนับหลักหน่วย (หลักขวาสุด) เป็นหลักแรกนะครับ

แล้ว Encoding ประเภทไหนที่เราจะใช้ในเกมล่ะ ???

ก่อนจะพูดถึงว่าเราจะใช้ประเภทไหน เราก็ต้องรู้ก่อนว่าข้อดีข้อเสียของแต่ละประเภทนั้นมันเป็นอะไรบ้างก่อนนะครับ

เมื่อนำทั้งสองตัวมาเปรียบเทียบกัน เราจะเห็นว่า

• Fixed-Length เนี่ย ข้อดีคือ มันง่ายที่จะ Implement ครับ เพราะรหัสทุกตัวจะยาวเท่ากันหมด ส่วนข้อเสียคือมันใช้พื้นที่เยอะกว่าอีกแบบ
• Variable-Length นั้น จะใช้พื้นที่น้อยกว่าครับ โดยเฉพาะถ้าเราเอาตัวอักษรที่ใช้บ่อยมาอยู่ในส่วนที่ใช้รหัสสั้น ๆ ได้ แต่ข้อเสียคือมันค่อนข้างลำบากกว่าที่จะ Implement

ดังนั้น ในเกม ซึ่งต้องการ Efficiency มาก ๆ เรามักจะใช้ Fixed-Length สำหรับการแสดงผล เพราะในระบบส่วนใหญ่จะมีหน่วยความจำมากเกินพอสำหรับการใช้งาน Encoding ประเภทนี้ครับ ในกรณีนี้การคำนวนที่เรียบง่ายนั้นเป็นสิ่งที่สำคัญกว่า และ Variable-Length จะใช้ในการส่งข้อมูลระหว่างเครื่องในเน็ทเวิร์ค เพราะขนาดของข้อมูลที่่รับส่งกันภายในเน็ทเวิร์คจะเล้กกว่า Fixed-length ทำให้รับส่งได้เร็วกว่าครับ

ถึงตรงนี้หลาย ๆ คนคงเดาออกแล้วว่าอะไรคืออะไร แต่ถ้ายังไม่รู้ ก็อ่านต่อเลยครับ

Character

คราวนี้จะมีเทคนิคัลเข้ามานิด ๆ นะครับ ไม่ต้องกังวลนะ ยังไม่ลงไปรายละเอียดครับ

สิ่งที่เราใช้แยกแยะตัวอักษรนั้นก็คือ ภาพของตัวอักษร (Glyph) และ เราเรียกตัวอักษรใด ๆ ด้วยชื่อ (Character Name) อย่างเช่น เราเรียก ก ว่า "กอไก่" หรือ A ว่า "เอ"

แต่การที่จะให้คอมพิวเตอร์ใช้สิ่งเหล่านั้นอย่างที่คนเราทำมันกลับเป็นเรื่องไม่ง่ายนัก การแยกแยะตัวอักษรจากภาพเป็นเรื่องยากของคอมพิวเตอร์มาหลายสิบปี ส่วนการใช้ชื่อเพื่อที่จะเรียกตัวอักษรนั้นเป็นเรื่องที่กินหน่วยความจำมากไปหน่อย

สิ่งที่คอมพิวเตอร์ใช้ ก็คือ รหัสตัวอักษร (Character Code) รหัสตัวอักษรก็คือรหัสตัวเลขที่คอมพิวเตอร์ใช้เพื่อแทนตัวอักษรนั่นเอง

โดยสรุปก็คือ Character คือ ชนิดของข้อมูลที่เก็บรหัสตัวอักษรไว้ นั่นเองครับ

แน่นอน พอมีรหัส มันก็ต้องมีการเข้ารหัส (Encoding) การเข้ารหัสจะเป็นการกำหนดว่ารหัสที่ใช้นั้นสร้างขึ้นมายังไง เช่น อาจจะเป็นตัวเลขชุดเดียว บอกว่าเป็นตัวอักษรที่เท่าไหร่ นับจากตัว A หรืออาจจะเป็นสองชุด หรืออาจจะเป็นอะไรที่พิสดารกว่านั้น

คุณสามารถสร้าง Encoding ของคุณเองก็ได้ ตราบใดที่เกมคุณสามารถถอดรหัสตัวอักษรได้แล้วแสดงผลได้ถูกต้อง

แต่ถ้าคุณคิดว่ามันไม่ฉลาดนักที่จะสร้างรหัสของตัวเอง ก็มีมาตรฐานให้ใช้อยู่มากมาย มาตรฐานที่ควรรู้จักก็ได้แก่ ASCII, ISO8859, ส่วนมาตรฐานของไทยก็มี มอก.620 เป็นต้น และมาตรฐานที่ใช้ร่วมกันทั่วโลกอย่าง Unicode (ผมจะพูดถึง Unicode ในภายหลังครับ)

เรื่องของ Encoding อยู่ในบทถัดไปครับ

Glyph

Glyph นั้นจริง ๆ อธิบายได้ง่าย มันก็คือ “ภาพ” ที่แสดงผลให้เราเห็น ตัวอักษรนั้นคือตัวอะไร

ถ้านึกไม่ออกลองดูภาพข้างล่างนะครับ

ภาพข้างบนดูแล้วมีตัวอักษรทั้งหมดห้าตัว ซึ่งหน้าตาไม่เหมือนกัน แต่เราแยกแยะได้ว่ามันคือตัวอักษร “ก” ครับ ที่มันหน้าตาไม่เหมือนกันเพราะมันเป็น Glyph คนละตัวกันนั่นเอง (ส่วนสาเหตุที่ Glyph เป็นคนละตัว เพราะเป็น Glyph ที่มาจากคนละฟอนท์ครับ

โปรแกรมคอมพิวเตอร์จะไม่สนใจว่า ไอ้ที่มันวาดอยู่บนจอน่ะมันคือภาพอะไร มันมีหน้าที่รู้แค่ว่า ถ้ามี Character ไหน มันจะเอา Glyph ไหนขึ้นมาวาด ก็เท่านั้นเองครับ

แล้วไอ้สองตัวนี้มันสัมพันธ์กันอย่างไร ?

อธิบายมาก็ยาว น่าจะมีคนสงสัยว่า แล้วจะพูดถึงทำไม ??? คำตอบก็คือ คอมพิวเตอร์ จะเก็บข้อมูลเป็น Character และแสดงผล Character นั้นด้วย Glyph ครับ  ซึ่ง Character และ Glyph จะถูกเก็บอยู่ในไฟล์ Font ครับ โดยไฟล์ Font จะเป็นตัวที่บอกว่า Character ไหน ใช้ Glyph ตัวไหนในการวาดครับ

สวัสดีครับ วันนี้อยากจะพูดเรื่องตัุวหนังสือกับเกมเสียหน่อย ไม่รู้จะมีใครสนใจมั้ย (แฮ่) จริง ๆ ว่าจะเขียนมาตั้งแต่สองปีที่แล้วแล้ว 55 เอาเถอะ เริ่มเลยละกัน

บทความชุดนี้จะมีกี่ตอนก็ยังนึกไม่ออกเหมือนกัน แต่ก็น่าจะยาวในระดับนึงนะครับ ตอนแรกนี้จะขอพูดเรื่องที่ไม่ได้เกี่ยวข้องกับการเขียนโปรแกรมเท่าไหร่ก่อน เป็นการปูพื้นเรื่องน่ะครับ

• ขอเริ่มจากคำศัพท์ก่อน
  Typeface คำนี้คือ ชุดของตัวอักษรที่มีลักษณะเหมือนกัน โดยอาจจะมีหลาย ๆ รูปแบบ เช่น ตัวหนา ตัวเอียง เป็นต้น
• Font เป็นคำที่ได้ยินกันติดหู แต่หลาย ๆ คนคงไม่รู้ว่ามันคืออะไร คำว่าฟอนท์หมายถึง ชุดของตัวอักษร ในรูปแบบใดรูปแบบนึง และอยู่ใน Typeface เดียวกัน ว่ากันง่าย ๆ ก็คือ subset ของ typeface นั่นเอง

มาถึงตรงนี้หลาย ๆ คนคงสงสัยว่ามันต่างกันยังไง ขอยกตัวอย่างก็แล้วกัน น่าจะเข้าใจง่ายกว่า

• Arial เป็น typeface
• Arial Regular, Arial Bold, Arial Italic เป็น font ครับ

เรื่องของ Typeset vs Font มันค่อนข้างงง ๆ เพราะหลาย ๆ เวปใช้ในคำจำกัดความที่ไม่ค่อยเหมือนกันเท่าไหร่ แต่เอาเป็นว่าแนว ๆ ที่ผมอธิบายก็แล้วกันครับ

Font Family ก็คือ ชุดของ Typeface ที่มีลักษณะใกล้เคียงกัน เช่น ชุดของฟอนท์ที่มีการใช้น้ำหนักเส้น ชุดของฟอนท์ที่มีเฉพาะสัญลักษณ์ เป็นต้น

Font Family ในภาษาอังกฤษ จะมีอยู่สองชุดหลัก ๆ ก็คือ Serif กับ Sans Serif

• Serif คือ Font Family ของฟอนท์ที่มี "หัว" และ น้ำหนักของเส้น
• ส่วน Sans Serif นั้นจะไม่มีการตวัดตรงหัว ไม่มีน้ำหนักเส้นครับ

ตัวอย่างครับ :-

ในบางครั้งเราอาจจะเห็น Gothic และ Romans ซึ่งจริง ๆ แล้ว Gothic ก็คือ Serif และ Romans ก็คือ Sans Serif ครับ

ในเกม เรามักจะใช้ตัวอักษรแบบ Sans Serif เพราะอ่านง่ายกว่า แลดูไม่รก แต่ในเกมที่ใช้ Theme แบบโบราณ เราก็อาจจะเห็นว่ามีการใช้ Font แบบ Serif บ้างเหมือนกัน เพื่อให้ภาพโดยรวมดูเก่านั่นเอง

หลังจากที่ดาวน์โหลดโปรแกรมเสร็จ แตกไฟล์ออกมาแล้วจะมีหน้าตาประมาณนี้

ซึ่งก็จะมีแค่ตัว Executable หนึ่งตัว ไฟล์ DLL นิดหน่อย กับ Folder ที่ชื่อว่า Plugin … โปรแกรมนี้จริง ๆ แล้วไม่มีอะไรเลย เหมือนเป็นโครงหลักให้ผุ้ใช้มาขยายมันมากกว่า ผ่าน Plugin นั่นเองครับ

เปิดโปรแกรมกันเลยดีกว่า

ทีนี้ กลับมาต่อกันที่ตัวโปรแกรม หลังจากที่เราดับเบิลคลิ๊กตัวไอคอนแดง ๆ แล้ว (แต่ต้องลง .Net Framework ก่อนนะ) จะมีหน้าต่างหลักขึ้นมาแบบนี้ครับ

โดยหลัก ๆ แล้วจะมีสองปุ่มใหญ่ ๆ อยู่บนหน้า (และอีกสองปุ่มเล็ก ๆ ซึ่งไม่ได้มีส่วนร่วมอะไรกับเขาเท่าไหร่) สองปุ่มนี้จะทำหน้าที่เปิดหน้าต่างอื่น ขึ้นมา ซึ่งก็มีสองหน้าต่างน่ะล่ะ

หน้าต่างแรกก็คือ

ตัววาด Glyph

Glyph หมายถึง ภาพตัวอักษร หน้าที่ของหน้าจอนี้คือ มันจะไปดึงเอาภาพ Glyph ในรูปแบบของ Vector จากไฟล์ Truetype ที่เราเปิดขึ้นมา แล้ววาดมันลงไปเป็นไฟล์ภาพแยกกัน พร้อมกับข้อมูลของแต่ละ Glyph ซึ่งจะถูกเขียนลงเป็นไฟล์ XML ครับ

เริ่มจาก เปิดไฟล์ฟอนท์ขึ้นมา แล้วก็กดปุ่ม Update โลด

จะเห็นตัวหนังสือขึ้นบนหน้าจอ Preview ตรงนี้อาจจะเห็นเป็นตัวขาด ๆ ไม่ค่อยสวย ลองเปลี่ยน Painter Type เป็น Gradient ปรับค่านิดหน่อย ใส่ขอบอีกนิด แล้วกด Preview ดูอีกทีครับ

เริ่มสวยละนะครับ

ถ้าอยากพรีวิวด้วยข้อความอื่น ก็ลองเปลี่ยนตัวหนังสือในช่อง Text ดูนะครับ

ในส่วนของ Painter นั้น ถ้าเกิดว่าตัวที่มากับโปรแกรมนั้นไม่ตรงกับที่ต้องการ ผู้ใช้สามารถเขียน Plugin เพิ่มเองได้ครับ โดยการสร้าง DLL ที่เชื่อมเข้ากับ Plugin-Interface.dll ซึ่งวิธีทำขอยกยอดไว้คราวหน้าล่ะกันครับ

เมื่อปรับจนพอใจแล้ว สิ่งต่อไปก็คือ กำหนดว่าให้เซฟไฟล์ไปไว้ที่ Path ไหน และใช้สคริปท์ใดบ้าง ซึ่งในส่วนของสคริปท์ก็คือชุดของ Glyph ที่ฝังอยู่ในไฟล์นั่นเอง โดยส่วนใหญ่จะเป็นเรื่องของภาษาครับ (แต่มีบางส่วนที่เป็นสัญลักษณ์บ้าง) อันนี้อ้างตามมาตรฐาน Unicode ครับ

สิ่งนึงที่ต้องระวังก็คือ ถ้าหากว่า ฟอนท์ต้นฉบับที่เราเอามาใช้ดันไม่มีสคริปท์ตัวที่เลือก ตัวโปรแกรมจะไม่เขียนไฟล์ภาพของสคริปท์นั้นลงไปใน Ouput นะครับ (เพราะไม่รู้จะใช้ตัวไหนนั่นเอง)

ว่าแล้วผมจะเลือกภาษาไทย และภาษาอังกฤษ ก็แล้วกันนะครับ จากนั้นก็เลือกว่าจะเซฟไฟล์ไว้ที่ไหน แล้วกด Start โลด

โปรแกรมจะทำการเรนเดอร์ไฟล์ภาพ และเขียนข้อมูลที่จำเป็น ลงไปใน Path ที่เราเลือกไว้ครับ

เสร็จแล้วจะได้ Output แบบนี้

ภายในไฟล์ xml จะมีข้อมูลของแต่ละ Glyph อยู่ ซึ่ง ก็จะมีบอกว่า Glyph นี้เป็นของ Character Code อะไร ขนาดเท่าไหร่ และข้อมูล Glyph Metrics ซึ่งผมจะพูดถึงในครั้งต่อๆ ไปครับ แต่ถ้าอยากอ่านเอารายละเอียดไว้ก่อนก็ลองอ่านจากเวปของทาง Freetype เองดูนะครับ ลองทำความเข้าใจดูนะครับ ไม่ยาก ๆ

ทีนี้กลับมาเรื่องเดิม เรากลับไปหน้าแรก แล้วลองกดปุ่มที่สอง หน้าต่างที่สองก็จะโผล่ออกมาดังนี้ครับ

ตัวสร้างฟอนท์

หน้าต่างนี้จะทำหน้าที่เอาข้อมูลที่สร้างขึ้นจากหน้าที่แล้ว มารวบรวมมาเป็นไฟล์ฟอนท์ที่เราต้องการครับ สิ่งที่ต้องทำก็คือ เพิ่มไฟล์ xml ที่เราสร้างจากหน้าที่แล้วมาไว้ในลิสต์ แล้วก็กดเริ่มต้น เท่านั้นเอง

ทีนี้ แล้ว ไฟล์ output ที่ได้นั้นเป็นอย่างไร … อันนี้ขึ้นอยู่กับว่าเลือก Converter อะไร ซึ่งผมใส่ Converter ตัวอย่างมาให้หนึ่งตัว ชื่อว่า Sample Converter นั่นเอง … ตัว Converter นี้จะสร้างไฟล์ฟอนท์เป็นภาษา Lua ตามฟอร์แมทที่ผมใช้ในเกมนึงของผม (ซึ่งล่มไปนานแล้วครับ 555) พร้อมกับไฟล์ภาพพร้อมใช้ครับ

ส่วน ถ้าอยากได้ฟอร์แมทอื่น คุณสามารถที่จะสร้าง plugin ของตัวเอง แล้วก็เรียกใช้ผ่านหน้าจอนี้เหมือนเดิมได้ครับ

ทีนี้ผมก็ได้ไฟล์ฟอนท์ไว้ใช้งานแล้วเรียบร้อย … ผมก็เอาใส่เข้าไปในตัวเกมผม แล้วก็ทดลองรันดูว่าใช้ได้มั้ย แล้วก็จบครับ

อะไรทำนองนี้ล่ะครับ

ในตอนนั้นผมเริ่มที่อยากเขียน Game Engine ของตัวเอง ซึ่งก็ได้มีโอกาสเขียนเหมือนกัน แต่ว่าเขียนในโปรเจคของบริษัท ซึ่งก็เป็นสินทรัพย์ของบริษัทไป ตอนนั้นตัว Engine ถ้าจำไม่ผิดรู้สึกว่ามันยังวาดตัวอักษรไม่ได้ แต่ผมวางแผนเอาไว้แล้วล่ะว่าจะไม่ใช้ระบบ Font ของวินโดวส์ เพราะอยากให้ Engine มัน Cross-Platform ได้ (รายละเอียดเกี่ยวกับโปรเจคนี้ผมคงไม่สามารถเปิดเผยได้มากนัก เอาเป็นว่า มันเคยมีละกัน) ก็มีการเตรียมออกแบบไฟล์ฟอนท์ไปบ้าง และมีการเขียนตัวแปลงฟอนท์

แต่หลังจากนั้นผมก็ลาออกจากที่นั่น และก็ไม่ทราบชะตากรรมของมันอีก (จริง ๆ ก็รู้แหละแต่ไม่บอกล่ะนะ 555)

โปรแกรมนี้ ไม่ใช่โปรแกรมแปลงฟอนท์ตัวที่ผมกล่าวถึงขั้นต้น (เพราะตัวนั้นเขียนด้วย Java ซึ่งลบไปนานละ มันยังใช้ไม่ได้ด้วยซ้ำ) แต่โปรแกรมที่ว่ามันก็เป็นจุดกำเนิดของโปรแกรมนี้เหมือนกัน …

อีกเรื่องนึงคือ ตอนนั้น ผมยังเล่นเกมประเภท Date Sim อยู่บ้าง เห็นหลาย ๆ เกมที่มีการวาด Font สวย ๆ ก็เลยอยากทำบ้าง ตัวที่เป็นแรงบันดาลใจจริง ๆ เป็นเกมของ StudioGU ที่ชื่อว่า Angel’s Tale

ผมเคยคุยกับโปรแกรมเมอร์เกมนี้ เขาว่า เกมนี้ทั้งหมดวาดด้วย GDI และ รวมทั้งตัวอักษรด้วย สังเกตให้ดีว่า ตัวอักษรจะมีการไล่สีในแนวตั้ง (Linear Gradient) และมีเส้นขอบด้านนอก ตัวอักษรจะเปลี่ยนสีไปตามคนพูด อย่างในภาพก็จะเป็นสีฟ้า

นอกจากนี้ก็จะเป็นเกมของ F&C อย่างเกม White Breath ข้างล่างนี้ ซึ่งตัวอักษรจะเป็นแค่ตัวอักษรสีขาวธรรมดา แต่จะมีเงาสีดำอยู่ด้านล่าง ก็ดูดีนะครับ อ้อ ขอบของตัวอักษรเป็น anti-aliasing ด้วยนะ

(ปล. เกมนี้ 18+ …)

ผมก็เลยเกิดบ้าพลังขึ้นมา อยากทำตัวแปลงฟอนท์ที่สามารถใส่เอฟเฟคตัวอักษรได้เอง

จริง ๆ ผมก็ตั้งใจเอาไว้ว่าจะทำ Game Engine ของตัวเองด้วย แต่ด้วยความขี้เกียจผมก็ล้มเลิกโปรเจคไป ตัวแปลงฟอนท์ตัวนี้ก็เลย … ไม่รู้จะเอาไปใช้กับอะไร สุดท้าย ผมก็เลยคิดว่า ทำไมเราไม่เอาโปรแกรมไปเปิดโค๊ดซะ แล้วก็ทำให้มันสามารถใช้กับ Engine อะไรก็ได้ ตราบเท่าที่ผู้ใช้สามารถประยุกต์มันได้

โปรแกรมแปลงฟอนท์ของผม ก็เลยไม่มีกำหนดเอาไว้ว่า Output จะหน้าตาเป็นอย่างไร แต่ะจะให้ผู้ใช้เขียน Plugin ขึ้นมาเพื่อที่จะกำหนด output format ของตัวเองซะเลย

หลังจากนั้นสักพักใหญ่ ๆ ผ่านไปสองปี นับจากที่ผมเปิดโค๊ด ผมก็ตัดสินใจอีกอย่างว่า ทำไมเราไม่ให้ผู้ใช้เขียน Plugin ขึ้นมา เพื่อที่จะกำหนดว่าหน้าตาของแต่ละ Glyph (ภาพตัวอักษร) จะเป็นเช่นไร ผมก็เลยทำอย่างนั้น

สรุปว่าตัวโปรแกรมจริง ๆ ก็เลยมีแต่แกนครับ ทุกอย่างผู้ใช้ต้องเขียนเพิ่มเอง อยากได้อะไรก็ทำเอง ว่างั้น !

เดี๋ยวจะเขียนอธิบายเป็น Tutorial สำหรับการเขียน Plugin ไว้ให้ภายในวันสองวันนี้ล่ะ เขียนไม่ยากจริง ๆ เพราะว่าสุดท้ายแล้วก็ขึ้นอยู่กับตัวคนเขียนว่าต้องการอะไรน่ะครับ

อ้อ แล้วก็มีการทำไอคอนกับโลโก้ครับ หน้าตาก็เป็นเยี่ยงนี้น่ะ

คิดไว้ว่า เดี๋ยวเก็บงานอีกหน่อย จะเริ่มเอาไปโฆษณาใน Gamedev.net แล้วล่ะครับ ก็หวังว่าจะมีคนเอาไปลองใช้มั่ง

ปล. ฟอนท์ที่ใช้ทำโลโก้ชื่อว่า Layiji ท่าไม้ตาย ครับ ออกแบบโดยคุณ Layiji เป็นฟอนท์ที่ตัวหนาสะใจเหมาะเอาไว้ทำเกมแนวจีน ๆ มาก แต่แนะนำว่าให้ลองติดต่อเจ้าของก่อนนะครับ เพราะฟอนท์ตัวนี้มี License ที่ละเอียดอ่อนนิดนึง คิดว่าถ้าเอาโปรแกรมผมไป Export ฟอนท์นี้ไปใช้โดยไม่บอกเจ้าของนี่อาจจะงานเข้าได้นะ 555