DEV Community: Wutipong Wongsakuldej

Can't avoid boilerplate? Use template project

Wutipong Wongsakuldej — Fri, 26 May 2023 14:57:59 +0000

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

เช่นแบบ เวลาเราทำโปรเจคที่เป็น React (สมมติ) เราก็ต้องมา import library เพิ่มทาสก์ใน package.json ต้องเขียนโค๊ดที่หน้าตาคล้าย ๆ กันจำนวนนึง จนกระทั่งมันรันขึ้นแล้วเราค่อยมาแก้ไขให้มันเป็นแอพลิเคชั่นที่เราต้องการ อะไรแบบนี้ใช่ไหมครับ

วิธีนึงที่จะมาช่วยคือสร้าง tool ที่ generate project file ทั้งหมด ซึ่งเป็นวิธีที่หลาย ๆ เฟรมเวิร์คใหญ่ ๆ ใช้ (React ก็ด้วย) เรียกว่ารันคอมมานด์แล้ว ใส่คำสั่งนิดหน่อย ก็ได้แอพรันขึ้นมาแล้ว

npx create-react-app my-app
cd my-app
npm start

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

Template Project ใน GitHub

ใน Github เองมีฟีเจอร์นี้อยู่ครับ เราสามารถสร้างโปรเจคขึ้นมาแล้วระบุว่าโปรเจคนี้เป็น Template ในหน้า Settings ของโปรเจค

แค่นี้โปรเจคนี้ก็จะกลายเป็นเทมเพลตของเราเรียบร้อย

จากนั้น เมื่อเราต้องการจะสร้างโปรเจคใหม่ เราก็แค่เลือกเทมเพลตใน dropdown ตอนสร้าง repository

หรืออีกทางเลือกหนึ่งคือ เปิดหน้า repository ของเทมเพลตที่จะใช้ แล้วกด "Use this template"

เมื่อ Repository ถูกสร้างเรียบร้อย เราจะได้ repository ใหม่ที่หน้าตาเหมือนกับตัวเทมเพลตเป๊ะ ๆ โดยที่เราไม่ต้องมานั่งก็อปปี้ไฟล์ไปมา

สิ่งที่แตกต่างคือ ตัวหัวโปรเจคจะระบุไว้ว่าสร้างจากเทมเพลตไหน และโปรเจคใหม่ที่สร้างขึ้นมาจะมีสถานะเป็นเหมือนโปรเจคใหม่ที่มี commit แรกจากตัวเทมเพลต ไม่มี branch ไม่มี history ที่ติดมาจากตัวเทมเพลต เรียกได้ว่าเริ่มต้นกันแบบคลีน ๆ ครับ

ทั้งนี้ ถ้าเกิดว่าตัวเทมเพลตเรามี GitHub Action อยู่ เมื่อเราสร้าง repository ใหม่ เราจะได้ Action ติดมาด้วย เนื่องจากว่าไฟล์ Action ก็เป็นแค่ source file ธรรมดาใน repository เท่านั้นเองครับ

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

Array ใน C++

Wutipong Wongsakuldej — Mon, 06 Feb 2023 14:24:52 +0000

ในยุคเริ่มต้น เรื่อง array ของ C++ เนี่ยจริง ๆ เป็นฟีเจอร์ที่ยกมาจากภาษา C ซึ่งเวลาเราประกาศตัวแปรเป็น array เราก็จะเขียนแบบนี้

int anArray[20];

เราก็จะได้ array ขนาด 20 ช่อง

ตรงนี้เมื่อเทียบกับภาษาสมัยใหม่ อย่างพวก C#, Java หรือแม้แต่ JavaScript ความแตกต่างอย่างหนึ่งของ array แบบ C คือ ขนาดของ array จะเป็นส่วนหนึ่งของ type ด้วย

แล้วก็ ตอนที่ initialize ค่าของ array จะต้องทำตอนที่ประกาศทันที ถ้าประกาศเสร็จแล้วเราอยากเปลี่ยนค่า ก็ต้องเปลี่ยนค่าทีละช่อง ราวกับว่าแต่ละช่องเหมือนเป็นตัวแปรตัวหนึ่ง

สาเหตุหนึ่งคือ array ใน C++ เป็น value type เมื่อคุณสร้าง array ขึ้นมาแล้ว ตัวภาษาจะกันพื้นที่ส่วนหนึ่งในหน่วยความจำไว้ให้เลย เหมือนมีตัวแปร int หลาย ๆ ตัวติด ๆ กันตรงนั้น ต่างกับภาษาอื่นที่ array มักจะเป็น reference ไปหาพื้นที่ที่อยู่ใน heap แทน

ดังนั้นเราจะเขียนแบบ (ยกตัวอย่าง java)

int[] anArray = new int[20];
anArray = new int[50];

ใน C++ ไม่ได้

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

ตัวอย่างข้างล่างนี้คอมไพล์ไม่ผ่าน

const int size = 20;
int array[size]; // error: ตอนคอมไพล์โค๊ดไม่รู้ว่า size มีค่าเท่าไหร่

Dynamic Array

ในภาษา C เนี่ย เราสามารถใช้ pointer ต่าง array ได้ คือเราเห็นตัวแปรไหนเป็น pointer เนี่ย สามารถใส่ subscript ตามหลังได้

int* anArray = (int*) malloc(sizeof(int) * 10); // หรือใช้ new int[10] แทนในภาษา C++
anArray[30] = 100;

แน่นอนว่าถ้าเราไปเข้าถึงพื้นที่ที่เราไม่ได้กันไว้ให้ตัวแปรนั้น มันก็จะพัง เท่านั้นเอง

line 110:    12 Segmentation fault

ซึ่งการใช้งานในลักษณะนี้จะเหมือนกับ array ในภาษาสมัยใหม่อย่างที่ว่าข้างบนครับ คือเราใช้ pointer ที่ชี้ไปหาพื้นที่หน่วยความจำที่เป็น array อีกทีนึง

ดังนั้น สำหรับคนที่เขียนภาษาอื่นมา ถ้าจะเขียน array บางทีเราอาจจะต้องใช้รูป dynamic array แบบนี้ครับ ไม่ใช่รูป array ปรกติ

อ้อ อีกอย่างครับ ลืม ... array สามารถแปลงร่างเป็น pointer ได้ครับ (แต่แปลงกลับไม่ได้นะ)

ปัญหาของการใช้ array แบบภาษา C

อย่างที่เล่าข้างบน Array ในภาษา C นั้น ขนาดของ array จะเป็นส่วนหนึ่งของ type ด้วย แต่ ... เราไม่สามารถบอกจากตัวแปรนั้น ๆ ได้ว่า array นี้มีขนาดเท่าไหร่

อันนี้รวมทั้ง array และ dynamic array ที่มาในรูป pointer ด้วย

คือคนเขียนจะต้องรู้เองว่า array เนี่ยมีขนาดเท่าไหร่ หรือ จะต้องส่งตัวแปรอีกตัวมาบอกว่า array นี้มีขนาดเท่าไหร่

void sort(int* array, int count);

หรืออีกวิธีคือ บังคับว่า ต้องปิดท้ายด้วยค่า 0 เท่านั้น ซึ่งพวกฟังก์ชันที่เป็นชุดของ string ในภาษา C จะใช้วิธีนี้ทั้งหมด (เรียกว่า null-terminated string)

size_t strlen ( const char * str );

ซึ่ง มันกลายเป็นว่า วิธีการใช้ array หรือ dynamic array มันก็เลยวุ่นวายแบบสุด ๆ ไปเลย

Array ใน C++ ยุคใหม่

ผ่านมาถึงปี 2007 เราคงคิดว่า เฮ้ย ... มันต้องเปลี่ยนแล้วมั้ย ภาษาอื่นเค้า array ใช้ง่ายมาก ทำไม C++ มันใช้ยากอย่างงี้

ก็เลยเกิด type ที่ชื่อ std::array ขึ้นมา

ผู้ใช้ก็ เฮ ... มีไทป์ใหม่แล้ว มันต้องใช้ง่ายเหมือนภาษาอื่นแน่เลย คำตอบคือ ไม่ใช่ครับ ไอ้ std::array เนี่ย จริง ๆ แล้วมันคือ wrapper ของไอ้ array แบบ C ธรรมดานี่ล่ะ

ดังนั้นข้อจำกัดที่ว่า ขนาดของ array เป็นส่วนหนึ่งของ type ก็ยังคงจริงอยู่เช่นเดิม

std::array<int, 10> anArray;

สิ่งที่ง่ายขึ้นคือ เราสามารถบอกขนาดของ array ได้จากตัวแปรนั้นละ และตัว std::array นี่ก็มีวิธีการใช้งานเหมือนกับ STL container อื่น ๆ ของ standard library ดังนั้นมันก็จะใช้ง่ายขึ้น มีเคสพิเศษน้อยลง

ทำ re-assignment ก็ยังได้เลย

std::array<int, 12> a = {0};
a = {20, 20};

แต่ไม่ได้หมายความว่า array ที่มี element type เดียวกันแต่ละคนละขนาด จะ assign กันได้นะครับ

อ้าวแล้ว Dynamic Array ล่ะ ?

จริง ๆ Dynamic Array ของ C++ นี่เกิดก่อน std::array อีก นั่นคือ std::vector ที่อยู่ในชุด STL นั่นเอง

หลายคนที่ไม่ได้ศึกษาจริงจัง จะไม่รู้ว่ามันใช้แทนกันได้ คือ std::vector เนี่ย ไส้ในมันคือ dynamic array และมันการันตีว่า ค่าต่าง ๆ ที่อยู่ข้างในนั้นจะวางอยู่ชิดติดกันเสมอ

คือที่เราเห็นว่า เฮ้ยเราสามารถแทรกค่าได้ สามารถนำค่าออกได้ สามารถขยายขนาดได้ ฯลฯ เนี่ย มันเกิดจากฟังก์ชันต่าง ๆ เค้า implement ข้างในให้หมดเลย เราเลยไม่ต้องแบบ realloc() หรือย้ายค่าไปมา ทั้งหมด คลาสนี้ทำให้หมดเลย

ในทางกลับกัน ถ้าเราใช้ std::vector เหมือนพวก container อื่น ๆ เช่นพวก linked list ก็อาจจะทำให้ performance หดได้เหมือนกัน

เวลาใช้ vector ให้คิดว่ามันคือ dynamic array เข้าไว้ครับ

แน่นอนว่ามันมีความแตกต่างอยู่บ้างครับ อย่าง สมมติเราระบุขนาด std::vector ไว้แบบนี้

std::vector<int> anVector(20);

ไอ้ตัว vector เนี่ย แทนที่มันจะกันที่ไว้แค่ 20 มันจะกันเผื่อไว้ประมาณนึง คือเค้าออกแบบมาเพื่อว่าเราอาจจะมีการเพิ่มหรือลด element ใน vector ไว้ได้วย ซึ่งถ้าเราซีเรียสเรื่องการใช้งานหน่วยความจำมาก ๆ การใช้ vector ก็อาจจะไม่เหมาะครับ

Ownership ในภาษา C++

Wutipong Wongsakuldej — Sun, 05 Feb 2023 11:52:08 +0000

ผมเห็นฟีเจอร์นึงของ Rust ที่มีคนพูดถึงคือ ownership ซึ่งมันเป็นการบอกว่า ตัวแปรไหน ใครเป็นเจ้าของ ใน C++ ก็มีฟีเจอร์นี้เหมือนกัน โดยเราเริ่มพูดคุยกันจริงจังในช่วงการพัฒนา Modern C++ (ก็ก่อน Rust หลายปีอยู่) แต่ว่ามันมาในรูปแบบของไลบราลีครับ ซึ่งก็คงจะไม่แน่นเท่าฝั่ง Rust

ก่อนจะไปถึงฟีเจอร์ในไลบราลีที่ว่านั่น ผมขอเริ่มจาก reference ก่อน

Reference

สมมติว่า เรามี struct นึง หน้าตาแบบนี้

struct Point {
   float x;
   float y;
}

และเรามีโค๊ดแบบข้างล่างนี้

Point p{ .x = 100.0f, .y = 200.0f}; // Designated Initializer ฟีเจอร์ใหม่ของ C++20

float &x = p.x;

คนที่เป็นเจ้าของ float ตัวนี้ก็คือ p ดังนั้นถ้า p ถูกทำลายไป ค่านี้ก็จะหายไปด้วย

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

ลองดูตัวอย่างถัดไป สมมติว่าผมมี

auto *p = new Point({.x = 200.0f, .y = 50.0f});
float &x = p->x;
delete p;

std::cout<<x<<std::endl; // error!

เป็นโค๊ดที่น่าเกลียดน่าดู (ฮา) คือ เนื่องจาก x เป็นค่าที่ refer ไปวัตถุที่ตัวพอยน์เตอร์ p ชี้ไป พอเราไปลบมัน x ก็เลย refer ไปไหนก็ไม่รู้ เพราะว่า x ไม่ได้เป็นเจ้าของตัววัตถุที่มัน refer ไปถึง

(เอาจริง ๆ เราก็ไม่ควรใช้ new/delete หรอกครับ แต่อันนี้ใช้แค่อธิบายโค๊ดเฉยๆ)

พูดง่าย ๆ reference มันเป็นแค่ป้ายครับ มันไม่ได้เป็นเจ้าของอะไร ก็เหมือนกับไอ้ NFT กับพวกงานศิลปะนี่แหละ NFT ไม่ได้แสดงความเป็นเจ้าของอะไร

ดังนั้นพอเราเห็น reference เนี่ย บอกได้เลยว่า มันไม่ได้เป็น owner ของวัตถุที่มัน refer ไป พอ reference หายไป ค่านั้นก็ยังอยู่ และถ้ามันดัน refer ไปหาวัตถุที่มีเจ้าของ และเจ้าของนั้นดันหายไปแล้ว reference นั้นก็จะพาลพังไปด้วย

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

Pointer

ต่อจาก reference ก็มาต่อที่ pointer ซึ่ง เมื่อเทียบกับ reference แล้ว อันนี้จะกำกวมมากกว่า คือ ถ้าเราเห็นตัวแปรเป็น reference เราสามารถบอกได้เลยว่า เฮ้ยเราไม่ได้ own ไอ้ค่าที่มันชี้ไปนะ แต่พอเป็น pointer เนี่ย เราบอกไม่ได้ว่าเราเป็นเจ้าของหรือเปล่า

เพราะมันอาจจะเป็นการรับค่ามาจาก reference operator ก็ได้ หรือมาจาก new operator ก็ได้เหมือนกัน หรือแม้กระทั่ง new[] operator หรือจะลามไปเป็น string ฯลฯ

ปวดหัวกันมากมาย

Smart Pointers

ในก๊วน C++ ก็เลยสร้าง type ใหม่ขึ้นมาสำหรับพวก pointer ที่เป็นเจ้าของวัตถุที่มันชี้ไป จะเรียกว่าใช้แทน new เลยก็ได้ โดยมีอยู่ 3 type ข้างล่าง (จริง ๆ มี 4 แต่ deprecate ไปหนึ่ง)

unique_ptr เป็น pointer ที่มีเจ้าของเพียงหนึ่งเดียวเท่านั้น ไม่สามารถสร้างก๊อปปี้ได้
shared_ptr เป็น pointer ที่ทุก ๆ ก๊อปปี้ของ pointer นี้เป็นเจ้าของร่วมกัน
weak_ptr เป็น pointer ที่ไม่เป็นเจ้าของใคร สามารถขอความเป็นเจ้าของชั่วคราวจาก shared_ptr ได้

`unique_ptr`

คำว่า "เจ้าของ" ในที่นี้นั้น จะผูกอยู่กับ lifetime ของตัว pointer เอง ในกรณีของ unique_ptr นั้น เมื่อตัว pointer ถูกทำลาย ตัววัตถุที่มันชี้ไปก็จะถูกทำลายตามไปด้วย อย่างเช่นตัวอย่าง

#include <memory>

{
    std::unique_ptr<int> p = std::make_unique<int>(200); 
} // สิ้น scop ตัว p ถูกทำลาย ค่าที่ p ชี้ไปก็จะถูกทำลายไปด้วย

ลักษรณะเฉพาะอันนึงที่ทำให้มัน unique คือ คุณไม่สามารถสร้างสำเนาของมันได้ วิธีเดียวที่จะสร้างสำเนาได้คือใช้ get() เช่น

std::unique_ptr<int> p1 = std::make_unique<int>(2000);
std::unique_ptr<int> p2(p1.get());

ซึ่งคงไม่ต้องให้บอกว่า หายนะกำลังรอคุณอยู่ ....

free(): double free detected in tcache 2
timeout: the monitored command dumped core

`shared_ptr`

สำหรับกรณีของ shared_ptr นั้น ตัว pointer จะถือ reference counter ร่วมกันอยู่ ทุกครั้งที่มีการสร้างสำเนาของ pointer เจ้า counter นี้ก็จะเพิ่มขึ้นด้วย และเมื่อสำเนาของ pointer นี้ถูกทำลาย counter ตัวนี้ก็จะลดลง

เมื่อ counter มีค่าเป็น 0 ตัวค่าที่ pointer ชี้ไปก็จะถูกทำลาย

#include <memory>

{
   std::shared_ptr<int> p1 = std::make_shared<int>(100); // counter = 1
   {
      std::shared_ptr<int> p2 = p1; //counter = 2
   } // สิ้น scope ใน p2 ถูกทำลาย counter = 1 
} // สิ้น scope นอก p1 ถูกทำลาย counter = 0 และ ค่าที่ชี้ไปก็ถูกทำลายด้วย

`weak_ptr`

และสุดท้าย คือ weak_ptr อันนี้จะงงนิดนึง เป็นตัวที่ใช้คู่กับ shared_ptr เราไม่สามารถใช้มันเดี่ยว ๆ ได้ และไม่สามารถใช้มันตรง ๆ ได้ด้วย

คืออารมณ์ประมาณนี้ครับ

#include <memory>

std::shared_ptr<int> sp = std::make_shared<int>(200);
std::weak_ptr<int> wp(sp); 
if(auto temp = wp.lock()) // lock ค่า wp เพื่อป้องกันไม่ให้ค่าที่ตัวมันชี้ไปถูกทำลายโดย sp 
                          // จริง ๆ คือมันก็สร้าง copy ของ sp แล้วคืนค่ากลับมาให้ใช้นี่ล่ะ
{
   std::cout<<*temp<<std::endl;
}

sp = std::make_shared<int>(2000); // เขียนค่าทับลงไป ทำให้ค่าเดิมที่ sp เคยชี้ไปหายไปด้วย

if(auto temp = wp.lock()) // wp ล๊อคไม่ได้ เพราะค่าที่มันเคยชี้ไปถูกทำลายไปแล้ว
{
   std::cout<<*temp;
} 
else 
{
   std::cout<<"failed to lock."<<std::endl; // ถึงจะล็อคไม่ได้ โปรแกรมก็ยังไม่พัง ก็ยังหายใจกันต่อ
}

200
failed to lock.

ผมคิดว่า weak_ptr นี่ เวลาใช้ต้องคิดนิดนึง แอบใช้ยากอยู่ครับ แต่มันมี use-case แหละ เมื่อเทียบกับ shared_ptr ซึ่งทำงานใกล้เคียงกับพวก reference ในภาษาอื่น ๆ แล้ว weak_ptr นี่ต้องคิดนิดนึงเวลาใช้เลยล่ะครับ

วิธีใช้ล่ะ?

ส่วนตัวผมใช้ unique_ptr สำหรับวัตถุหนึ่งเดียวที่มีในโปรแกรม พวกวัตถุที่แทนค่า device หรือพวก global instance ต่าง ๆ

ส่วน shared_ptr จะเป็นพวก pointer ทั่ว ๆ ไป พวก instance ต่าง ๆ จะใช้ตัวนี้ครับ

ส่วน weak_ptr นี่ ผมว่าเหมาะกับการเอาไปใช้ใน function ที่รับค่าเป็น shared_ptr reference อย่างน้อยก็เช็คได้ว่าค่าที่มันชี้ไปยังใช้งานได้นะ แล้วก็เหมาะกับพวก instance ที่ไม่ได้แคร์ว่า ไอ้ pointer ที่มันถืออยู่จะใช้ได้หรือไม่ได้ ถ้าใช้ไม่ได้ก็ข้ามไป อะไรแบบนี้ครับ (อธิบายยากนิดนึง)

แล้วเคสอื่นๆ ล่ะ

เอากรณีที่ผมนึกออกนะครับ

ใช้ pointer เป็น string << ใช้ std::string แทน
ใช้ pointer เป็น dynamic array << ใช้ std::vector แทน อันนี้หลายคนไม่รู้ จริง ๆ std::vector ก็คือ wrapper ของ dynamic array นี่ล่ะ ใช้ง่ายกว่าด้วย

แล้วพอหมดพวกเคสพิเศษพวกนี้ ที่เหลือคือกรณีที่ pointer มันชี้ไปหาวัตถุที่มีเจ้าของอยู่แล้ว อันนี้คือเราปล่อยได้เลย ไม่ต้องไปยุ่งกับมันครับ

สรุป

ตัว ownership เป็นคอนเซปท์ที่ เอาจริง ๆ ณ.จุดนี้ก็ไม่ใหม่แล้ว แต่ว่าสำหรับคนที่เขียนโค๊ดสไตล์เก่าแบบ C++98 มานานก็อาจจะไม่คุ้นเคย

คอนเซปท์นี้ เมื่อใช้ร่วมกับ datatype ที่ออกแบบมาเพื่อทดแทนการใช้งาน pointer นอกเหนือจากความเป็น pointer (เช่น string, dynamic array) จะทำให้เราสามารถเขียนโค๊ดที่ปลอดภัยได้มากขึ้น ลดอัตราการเกิด dangling pointer และ memory leak ได้มากขึ้นครับ

Reference

Dynamic Memory Management - cppreference.com

SoLoud - Game Audio Engine ที่ใช้งานง่าย (มาก) และ opensource สำหรับ C++

Wutipong Wongsakuldej — Sun, 29 Jan 2023 11:20:21 +0000

หลาย ๆ คนที่ยังเขียนเกมแบบเขียนเอนจินเอง น่าจะเคยเขียนส่วนที่เล่นเสียง ไม่ว่าจะใช้ DirectSound, XAudio, SDL2 แล้วรู้สึกว่า ทำไมมันช่างลำบากเหลือเกิน เล่นแค่ให้เสียงออกน่ะง่าย แต่ควบคุมให้มันทำงานได้ดังใจนี่มันช่างวุ่นวาย

ในทางกลับกัน บางคนก็อาจจะเคยได้จับ Engine เฉพาะ อย่าง AudioKinetic WWise หรือ FMOD มาก่อน แต่ก็สู้ราคาเอนจินไม่ไหว เพราะแพงจับใจ (ถึงไลเซนส์อินดี้จะฟรีก็ตาม)

วันนี้จะขอแนะนำ SoLoud มาเป็น Audio Engine อีกสักตัวนึง แต่ก่อนจะไปถึงขั้นนั้น มาดูกันก่อนว่า ทำไมเราถึงต้องมี Audio Engine หรือ Middleware หรือ Library หรืออะไรต่อมิอะไรที่เราเรียกกัน

ความจำเป็นของ Audio Engine

บางคนคงคิดว่า การเล่นเสียงมันไม่น่าจะยาก แค่สร้าง audio data แล้วเรียกฟังก์ชั่นของ OS มันก็เล่นให้ได้แล้ว ในความเป็นจริงคือ เวลาเราสร้าง audio device ขึ้นมาสักตัวนึง เราจะได้สตรีมของ audio มาสายนึง เวลาเราเล่นเสียง ตัว api ก็จะทำการเขียนข้อมูล PCM นี้ลงไปใน stream ที่ว่า

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

ถ้าเราจะเล่นหลาย ๆ เสียงพร้อม ๆ กัน หรือเหลื่อม ๆ กัน เราจึงไม่สามารถใช้ฟังก์ชั่นที่ว่าได้ตรง ๆ เราจำเป็นจะต้อง mix ทุกเสียงรวมกันให้เหลือแค่เสียงเดียว แล้วจึงเขียนลงไปในสตรีม

ดังนั้น ฟังก์ชั่นหลักที่สำคัญที่สุดของ Audio Engine คือการผสมเสียงก็ว่าได้

ทีนี้ ด้วยความที่ว่า audio เป็นงานที่สัมพันธ์กับเวลา เราไม่สามารถเขียนข้อมูลลง stream เร็วไปหรือช้าไปได้ มันจะต่างกับงาน graphics ที่ เราสามารถวาดเฟรมใหม่ทันทีได้หลังจบเฟรม ถ้าเราทำแบบนั้นในงาน audio จะเกิด stutter คือเสียงมันถูกส่งมาเร็วเกินไปทำให้มีข้อมูลบางส่วนถูกข้ามไป หรืออาจจะส่งมาช้าเกินไปทำให้มีจังหวะที่เสียงเงียบได้อีกด้วย ดังนั้นงาน audio จะมีจังหวะของมันเองและไม่ขึ้นอยู่กับกราฟิค นอกจากนี้เสียงที่ถูกส่งเข้ามาเล่นอาจจะมีขนาดที่ใหญ่กว่าตัวบัฟเฟอร์ของสตรีมนั้นๆ ทำให้จะต้องเก็บข้อมูลบางส่วนเอาไว้ใช้ตอนเติม buffer ครั้งต่อ ๆ ไปหลังจากนั้นอีก

การเขียนโค๊ดที่ใช้ผสมเสียง หรือที่เรียกว่า mixer จึงเป็นงานที่ไม่ธรรมดา มีความซับซ้อนระดับหนึ่ง และยิ่งมีฟีเจอร์มากเท่าไหร่การสร้างก็จะยากขึ้นเท่านั้น

SoLoud คืออะไร ?

SoLoud เป็น Open Source, Cross-Platform Audio Engine ที่พัฒนาโดย Jari Komppa ตัวมันวางตัวยู่บน Audio Backend ต่าง ๆ เช่นพวก SDL2, ALSA, หรือ WinMM แล้วเราสามารถเล่นเสียงได้โดยง่าย และสามารถควบคุมโวลุ่ม ควบคุมการแพน หรือแม้กระทั่งเพิ่มเอฟเฟคอย่างรีเวิร์ปเข้าไปได้ด้วย

ทีนี้ ถ้าถามว่า ใช้ง่ายแค่ไหน ข้างล่างคือโค๊ดตัวอย่างครับ


int main() {
  SoLoud::SoLoud soloud;
  SoLoud::Wav sample;

  soloud.init();

  sample.load("sfx.wav");
  auto handle = soloud.play(sample);
  soloud.setVolume(handle, 0.5f);
  soloud.setPan(handle, -0.2f);
}

แค่นี้ก็เล่นเสียงจากไฟล์ sfx.wav ไปออกทางซ้าย 20% และเสียงดัง 50% จากต้นฉบับ เรียบร้อย

และถ้าเราเล่นไฟล์หลาย ๆ ไฟล์พร้อม ๆ กัน SoLoud จะผสมเสียงให้เอง เราไม่ต้องเขียนฟังก์ชั่นสำหรับผสมเสียงละ

ลักษณะเฉพาะนึงของ SoLoud คือ Library นี้จัดการเรื่อง lifetime ได้ดี ถ้าสังเกตคือตัว interface แทบจะไม่มี pointer เลย ทั้ง ๆ ที่เป็น library ที่ผู้ใช้สามารถขยายความสามารถได้ง่าย อันนี้เกิดจาก Library ออกแบบมาให้เราจัดการ state ทั้งหมดผ่าน stack variable ทำให้เกิด memory leak จากฝั่งคนใช้ได้ยากขึ้น

Demo Time!

อันนี้เป็นเดโมที่ผมเขียนไว้ ใช้ SDL2 กับ ImGUI ครับ สามารถไปดาวน์โหลดได้ที่ Github Release 0.1 มีแต่ Windows นะครับ

เนื่องด้วยจากความขี้เกียจของผม ผมจึงใส่เกือบทั้งหมดลงไปในใน main.cpp ยกเว้นส่วนที่เป็น file กับ joystick อันนี้ไม่ต้องไปทำความเข้าใจมากก็ได้ครับ อย่างตัว FileSystemFile นี่สามารถใช้ SoLoud::File หรือไปใช้พวกฟังก์ชั่นที่อ่านไฟล์ได้เองตรง ๆ ก็ได้ครับ ที่ผมเขียนคลาสนั้นขึ้นมานี่ เขียนมาเพื่อรอง std::filesystem::path แค่นั้นเลย

SoLoud::Soloud

คลาส Soloud นี้เป็นคลาสหลักของตัว Engine เป็นเหมือนตัว root level device ที่เวลาที่เราจะทำอะไรกับ SoLoud คลาสนี้แหละที่เราจะไปยุ่งด้วย

คือจะมองว่าเป็นตัวเล่นเสียง + ตัวผสมเสียงในตัวเดียวก็ได้ครับ

SoLoud::AudioSource

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

ตัว SoLoud มีคลาสชุด AudioSource ติดมาให้จำนวนหนึ่ง ข้างล่างนี้เป็นตัวอย่างบางส่วนครับ

SoLoud::Wav sample;
sample.load("sfx.wav");

SoLoud::WavStream bgm;
bgm.load("bgm01.mp3");

SoLoud::Speech speech;
speech.setText("Hello World", 11);

SoLoud::Sfxr sfxr;
sfxr.loadPreset(SoLoud::Sfxr::COIN, 654'321);

soloud.play(sample);
soloud.play(bgm);
soloud.play(speech);
soloud.play(sfxr);

Wav เป็น Source ที่เก็บข้อมูลเสียง PCM จากไฟล์ทั้งไฟล์มาเก็บไว้
WavStream ต่างกับ Wav ตรงที่ตัวมันเองจะอ่านข้อมูลแบสตรีมมิ่งจากไฟล์ระหว่างการเล่น ทำให้ใช้เมมโมรี่น้อยกว่า แต่ก็แลกมาด้วยจำนวน I/O Operation เพราะมันจะอ่านไปเล่นไป
Speech เป็นตัวสังเคราะห์เสียงพูดภาษาอังกฤษอย่างง่าย เอาไว้ทำเสียงพูดขำๆ
SFXR ไลบราลีสำหรับสร้างซาวนด์เอฟเฟคด้วย synthesizer ตัว
และอื่นๆ

Bus

Bus เป็น Audio Source ที่พิเศษตรงที่ตัวมันเองจะรับเสียงจาก Audio Source อื่น ๆ ก่อนจะส่งไปที่ตัว Soloud object

Bus ทำตัวเป็น submix ที่เราสามารถนำเสียงที่อยู่ในกลุ่มเดียวกันมารวมกันในจุดเดียว เพื่อที่จะควบคุมเสียงพร้อ ๆ กันได้ในทีเดียว

soloud.play(aBus);
for(int i = 0; i< sources.size(); i++){
    aBus.play3d(sources[i], positions[i].x, positions[i].y, positions[i].z);
}

ยกตัวอย่างเช่น เกมอย่าง Rockman/Megaman X จะมีเสียงซาวนด์เอฟเฟคต่างๆ และเสียงเพลง background music เมื่อเรากด pause เสียงซาวนด์เอฟเฟคทั้งหมดจะหยุดชั่วคราว เสียง background music จะเบาลง และเมนูจะแสดงขึ้นมา เมื่อเรากดปุ่ม ซาวนด์เอฟเฟคในหน้าเมนูก็จะดังตามปรกติ

soloud.setPause(sound_efx_bus_handle, true);

เมื่อเรากดปิดเมนู เสียงซาวนด์เอฟคเดิมจะเล่นต่อจากจุดที่หยุดชั่วคราว เสียง background music จะกลับมาดังเหมือนเดิม และเสียงเมนูก็จะหายไป

soloud.setPause(sound_efx_bus_handle, false);

ตรงเราสามารถทำได้โดยการให้ sound effect ในเกมรันอยู่บน bus หนึ่ง แล้วเรา play/pause ตัวบัสนี้เมื่อกด pause เข้าเมนู/ออกจากเมนู โดยที่เราไม่ต้องไปหยุด sound source ย่อย ๆ ทีละตัว

Manipulation

สำหรับ Soloud เราสามารถสั่งเล่น audio source เดียวกันหลาย ๆ ครั้งพร้อม ๆ กันได้ ยกตัวอย่างคือเสียงปืน ที่มักจะเป็นเสียงเดียวกัน และอาจจะเล่นพร้อม ๆ กันหรือเล่นต่อ ๆ กันได้

ทีนี้ แล้วเราจะควบคุมเสียงที่เล่นออกมาแล้วได้อย่างไร? เวลาที่เราเล่นเสียง ฟังก์ชั่น play() จะคืนค่า integer ออกมาตัวหนึ่ง ที่เรียกว่า handle

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

SoLoud::Wav wav;
wav.load("gunshot.wav");

auto handle = soloud.play(wav);
soloud.setVolume(handle, 0.7f);
soloud.setPan(handle, 0.2f); // 20% to the right.

Filter

filter เป็นเหมือนเอฟเฟคที่ทำงานคู่กับ audio source เช่น เราอาจจะอยากให้เสียงพูดมีลักษณะเหมือนเสียงหุ่นยนต์ เราอาจจะอยากให้เสียงเพลงมีลัษณะเหมือน lofi เราอาจจะอยากให้เสียงที่วิ่งผ่านบัสซาวนด์เอฟเฟคมีเสียงรีเวิร์ป ตรงนี้เราสามารถทำได้หมดเลย และง่ายมากด้วย

source.setFilter(0, &lofi_filter);

aBus.setFilter(0, &echo_filter);

ข้อจำกัด

SoLoud ติดต่อกับ backend ด้วยโค๊ดที่เลเวลล่างมาก ตัวมันเองคำนวนตำแหน่งสามมิติด้วยตัวมันเอง แทนที่จะให้ backend คำนวนให้ ทำให้ไม่สามารถใช้ศักยภาพของแพลตฟอร์มได้ดีนัก อย่างพวก 3D Binaural Audio ด้วยการใช้ฮาร์ดแวร์นี่ทำไม่ได้ และตัวมันเองก็ยังไม่รองรับ HRTF ด้วย

อุปสรรคในการใช้งาน

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

ทั้งนี้เค้ามีก็ premake script ให้แหละ แต่กับคนที่ไม่ใช้ premake ก็ไม่มีประโยชน์อะไรเท่าไหร่

ทิ้งท้าย

สำหรับคนที่ยังเขียน C++ อยู่ และอยากจะ modernize โค๊ดตัวเอง เอาโค๊ดของตัวเองที่อาจจะดูและไม่ดีนักออก แล้วเอาโค๊ดที่ดูแลดีกว่าของคนอื่น (ที่เป็นโปรเจคที่ร่วมกันทำงานหลายคน และร่วมกันเป็นเจ้าของ) มาใช้แทน สำหรับภาค Game Audio ผมว่า SoLoud นี่ก็ถือว่าตอบโจทย์ได้ดีทีเดียวครับ ใช้งานง่าย ลูกเล่นเยอะ แถมทำงานได้หลายแพลตฟอร์มอีก

ส่วนตัวผมรู้จัก SoLoud จากการไปลองศึกษา The Forge ที่เป็นเหมือนเฟรมเวิร์คสำหรับเขียนเกม ถูกใช้ในเกมที่วางขายแล้วจำนวนหนึ่ง รวมทั้ง AAA อย่าง Starfield และ No Man Sky คิดว่า โค๊ดที่ถูกใช้ในโครงการระดับนี้ก็น่าจะถูกคัดกรองมาดีระดับหนึ่งแล้วครับ

อันนี้ใครสนใจก็ลองหามาเล่นดูได้ครับผม