OpenSL ESでActivityが非アクティブになった時に音を停止する簡単な方法

前回OpenSL ESでサウンドを再生しましたが、Activityが非アクティブになっても音が鳴り続ける問題がありました。それに対しての簡単な対処法として、バッファを細かく分けてEnqueueしてみました。Enqueueは32768バイト単位でしています。（サイズは適当です）

	void Voice::Play(bool loop)
	{
	if (!IsReady()) {
	return;
	}
	auto playback = [](SLAndroidSimpleBufferQueueItf q, void* context_) {
	double now = GetTime();
	if (now - systemMisc.GetLastUpdateTime() >= 0.5) {
	return;
	}
	WaveContext* context = (WaveContext*)context_;
	int totalSize;
	const void* buf = RiffFindChunk(context->fileImg, "data", &totalSize);
	int enqueued = context->enqueuedSize;
	if (enqueued >= totalSize) {
	if (!context->loop) {
	return;
	}
	enqueued = 0;
	}
	int toEnqueue = std::min(totalSize - enqueued, 32768);
	enqueued += toEnqueue;
	context->enqueuedSize = enqueued;
	SLCall(q, Enqueue, (char*)buf + enqueued - toEnqueue, toEnqueue);
	};
	SLCall(context->playerPlay, SetPlayState, SL_PLAYSTATE_STOPPED);
	SLCall(context->playerBufferQueue, RegisterCallback, playback, context);
	context->enqueuedSize = 0;
	context->loop = loop;
	SLCall(context->playerPlay, SetPlayState, SL_PLAYSTATE_PLAYING);
	playback(context->playerBufferQueue, context);
	}

view raw opensl_play2.cpp hosted with ❤ by GitHub

最終アップデートからの経過時間が0.5秒を超えたらコールバック無視します。この方法の長所は、コールバック一つでループ再生と非アクティブになった時の音停止を同時に実装でき、コードが簡潔になります。Activityから非アクティブの通知を受け取る必要もありません。短所としては、アップデートループで長い処理をすると音が切れてしまうことです。

また、停止した音を再開する処理を盛り込んでいません。ここは、ゲーム毎の実装依存が多いと思いあえてしませんでした。例えば多くの場合は再開すべき音はBGMだけであったりするでしょう。

AndroidのOpenSL ESはコールバックは別スレッドから来るので特に気をつける必要があります。Android特有の実装についてはNDKのdocs/Additional_library_docs/opensles/index.html に説明があるので、一度目を通しておくと良さそうです。

実践OpenSL ES、AndroidでWAVファイル再生

OpenSL ESによるサウンドエンジンを使い物になるように書いてみます。

まず、気づくのはDirectXを彷彿させるインターフェース型のAPIであることです。多くのメソッドはSLresultで結果を返し、Destroyでリソースを解放して終了します。素直に書くと冗長なコードになりそうですが、まず最初にDirectX開発者にはおなじみの手法を導入します。

	template <class T> void SafeDestroy(T& p)
	{
	if (p) {
	(*p)->Destroy(p);
	p = nullptr;
	}
	}
	SLresult _slHandleError(const char* func, int line, const char* command, SLresult r)
	{
	if (r != SL_RESULT_SUCCESS) {
	const char *err = nullptr;
	switch (r) {
	#define E(er) case er: err = #er; break
	E(SL_RESULT_PRECONDITIONS_VIOLATED);
	E(SL_RESULT_PARAMETER_INVALID);
	E(SL_RESULT_MEMORY_FAILURE);
	E(SL_RESULT_RESOURCE_ERROR);
	E(SL_RESULT_RESOURCE_LOST);
	E(SL_RESULT_BUFFER_INSUFFICIENT);
	E(SL_RESULT_CONTENT_CORRUPTED);
	E(SL_RESULT_CONTENT_UNSUPPORTED);
	#undef E
	default:
	aflog("%s(%d): err=%d %s\n", func, line, r, command);
	return r;
	}
	aflog("%s(%d): %s %s\n", func, line, err, command);
	}
	return r;
	}
	#define SLHandleError(command) _afHandleSLError(__FUNCTION__, __LINE__, #command, command)
	#define SLCall(obj,func,...) afHandleSLError((*obj)->func(obj, __VA_ARGS__))

view raw opensl_fundamental.cpp hosted with ❤ by GitHub

SafeDestroyはDestroy呼び出しと同時にnullptrを代入してダングリングポインタにならないようにします。

SLHandleErrorというのは、各種メソッドがエラーコードを返したらソースコード上の行数と関数呼び出しの概要をログに出力するためのマクロです。Direct3D9のサンプルでは"V"という一文字のマクロが多用されていましたが、それです。

SLCallは、インターフェース呼び出しをすっきり書きたいがために書いたマクロです。これを使ってエンジンの初期化と終了を書いてみます。

	class SL {
	SLObjectItf engineObject = nullptr;
	SLEngineItf engineEngine = nullptr;
	SLObjectItf outputMixObject = nullptr;
	public:
	SL() {
	SLHandleError(slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr));
	SLCall(engineObject, Realize, SL_BOOLEAN_FALSE);
	SLCall(engineObject, GetInterface, SL_IID_ENGINE, &engineEngine);
	SLInterfaceID ids = SL_IID_ENVIRONMENTALREVERB;
	SLboolean req = SL_BOOLEAN_FALSE;
	SLCall(engineEngine, CreateOutputMix, &outputMixObject, 1, &ids, &req);
	SLCall(outputMixObject, Realize, SL_BOOLEAN_FALSE);
	}
	~SL() {
	SafeDestroy(outputMixObject);
	SafeDestroy(engineObject);
	engineEngine = nullptr;
	}
	SLEngineItf GetEngine(){ return engineEngine; }
	SLObjectItf GetOutputMixObject() { return outputMixObject; }
	};
	static SL sl;

view raw opensl_initialization.cpp hosted with ❤ by GitHub

エンジンの初期化と終了が書けました。

DirectXから来ると戸惑うのが、SLObjectItfとその他インターフェースに分かれていることです。OpenSLでは全てのインスタンスの実体はSLObjectItfであって、何らかのメソッド呼び出しが必要になったらSLObjectItfから追加のインターフェースを取得します。また、SLObjectItfをDestroyするとSLObjectItfから取得したインターフェースも一緒に無効になります。

engineEngineがSafeDestroyではなくnullptrを代入しているのは、engineObjectをSafeDestroyした時に一緒に消滅しているからです。

次は、WAVファイルをロードして"audio player"を作ってみます。

	struct WaveFormatEx {
	uint16_t tag, channels;
	uint32_t samplesPerSecond, averageBytesPerSecond;
	uint16_t blockAlign, bitsPerSample;
	};
	struct WaveContext
	{
	SLObjectItf playerObject;
	SLPlayItf playerPlay;
	SLAndroidSimpleBufferQueueItf playerBufferQueue;
	void *fileImg;
	int enqueuedSize;
	bool loop;
	};
	void Voice::Create(const char* fileName)
	{
	context = new WaveContext;
	memset(context, 0, sizeof(*context));
	bool result = false;
	result = !!(context->fileImg = LoadFile(fileName));
	assert(result);
	const WaveFormatEx* wfx = (WaveFormatEx*)RiffFindChunk(context->fileImg, "fmt ");
	assert(wfx);
	SLDataLocator_AndroidSimpleBufferQueue q = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
	SLDataFormat_PCM f = {SL_DATAFORMAT_PCM, wfx->channels, wfx->samplesPerSecond * 1000, wfx->bitsPerSample, wfx->bitsPerSample, wfx->channels == 2 ? SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT : SL_SPEAKER_FRONT_CENTER, SL_BYTEORDER_LITTLEENDIAN};
	SLDataSource src = {&q, &f};
	SLDataLocator_OutputMix m = {SL_DATALOCATOR_OUTPUTMIX, sl.GetOutputMixObject()};
	SLDataSink sink = {&m, nullptr};
	SLInterfaceID ids = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
	SLboolean req = SL_BOOLEAN_TRUE;
	SLCall(sl.GetEngine(), CreateAudioPlayer, &context->playerObject, &src, &sink, 1, &ids, &req);
	SLCall(context->playerObject, Realize, SL_BOOLEAN_FALSE);
	SLCall(context->playerObject, GetInterface, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &context->playerBufferQueue);
	SLCall(context->playerObject, GetInterface, SL_IID_PLAY, &context->playerPlay);
	}

view raw opensl_wave_player.cpp hosted with ❤ by GitHub

CreateAudioPlayerで、WAVファイルの特性（ステレオ/モノラル、サンプリングレート、ビット数）に合わせた"audio player"を生成します。WaveFormatExはWindows APIにあるWAVEFORMATEX構造体で、この情報からSLDataFormat_PCM構造体を構築します。リファレンス通りに書くとまたコードが長くなりそうですが、例えばSL_SAMPLINGRATE_44_1は44100000と定義されていたりします。samplesPerSecondを1000倍して代入すれば良いわけです。事前定義値は https://www.khronos.org/registry/sles/api/1.1/OpenSLES.h にあります。

次はWAVファイルの再生部です。

	void Voice::Play(bool loop)
	{
	if (!IsReady()) {
	return;
	}
	auto playback = [](SLAndroidSimpleBufferQueueItf q, void* context_) {
	WaveContext* context = (WaveContext*)context_;
	int totalSize;
	const void* buf = RiffFindChunk(context->fileImg, "data", &totalSize);
	SLCall(q, Enqueue, (char*)buf, totalSize);
	};
	auto doNothing = [](SLAndroidSimpleBufferQueueItf, void*) {};
	SLCall(context->playerPlay, SetPlayState, SL_PLAYSTATE_STOPPED);
	SLCall(context->playerBufferQueue, RegisterCallback, loop ? playback : doNothing, context);
	SLCall(context->playerPlay, SetPlayState, SL_PLAYSTATE_PLAYING);
	playback(context->playerBufferQueue, context);
	}

view raw opensl_play.cpp hosted with ❤ by GitHub

Enqueueで再生するバッファを指定します。ループ再生する場合はコールバックを登録して、コールバックからEnqueueを繰り返します。コールバック設定前にSL_PLAYSTATE_STOPPEDを明示するのはステートがSL_PLAYSTATE_STOPPEDではない場合にSL_RESULT_PRECONDITIONS_VIOLATEDエラーが発生するためです。これはPlayメンバ関数が二回目に呼ばれた場合に起こります。

これで、OpenSLの初期化からWAVファイルの再生までができました。ところで、この方法だとActivityが非アクティブになっても音が鳴り続けるという問題があります。この解決は次回書きます。

Luaのrequireで独自ファイルシステム上のスクリプトをロード

requireでAndroidのAPKのassetsフォルダからスクリプトを読み込みたくて、方法を探ってみました。requireはCのincludeに似た使い方をしますが、requireの実体はモジュール名を引数に取るただの関数です。

dofileとrequireはよく似た関数ですが、いくつか違いがあります。まずrequireは通常拡張子".lua"無しでモジュールを指定します。これを実装してみます。

	function require(m)
	dofile(m..".lua")
	end

view raw replace_require.lua hosted with ❤ by GitHub

前回、dofileのファイルシステムを置き換えているので置き換え版のdofileを流用することでLuaだけで書けました。厳密にはpackage.pathを考慮していないという問題がありますが、これだけで用足りることも多いと思います。

ところで、requireで比較的重要なdofileとの違いが、重複requireガードです。これはpackage.loadedテーブルにロード結果が記録される事で行われます。実際にテーブルの中身をprintで出力してみると、以下のようになりました。（左がキー、右が値）

debug   table: 00C9D770
vec4    true
coroutine       table: 00C98AA8
_G      table: 00C92760
package table: 00C98828
math    table: 00C9A2D0
my_class        userdata: 00C9C3B8
io      table: 00C98C38
os      table: 00C99880
bind_win        true
string  table: 00C99FB0
utf8    table: 00C9D6D0
table   table: 00C98BE8

キーを見ると、luaL_openlibsでロードされるLuaの標準ライブラリに混じってrequireでロードしたモジュール（ここではvec4, bind_win, my_classがそれです）の名前が見えます。対して値はそのモジュールをロードした時のreturn値が格納されています。（return値が無い場合はtrue）

また、この値は同じモジュールの二回目以降のrequireで返される値としても使われます。以下の例は、dofileが毎回math.random()を実行するのに対して、requireは初回呼び出し時の値をpackage.loadedにキャッシュする事を確かめるものです。

	print("calling with dofile", dofile("random.lua"), dofile("random.lua"), dofile("random.lua"))
	print("calling with require", require("random"), require("random"), require("random"))
	assert(require("random") == package.loaded["random"])

view raw caller.lua hosted with ❤ by GitHub

return math.random()

view raw random.lua hosted with ❤ by GitHub

以上を踏まえたファイルシステム置き換え版のrequireは以下のようになります。

	function require(m)
	package.loaded[m] = package.loaded[m] or dofile(m..".lua") or true
	return package.loaded[m]
	end

view raw replace_require_cached.lua hosted with ❤ by GitHub

Luaのdofileで使うファイルシステムを置き換える

Luaはdofile等でスクリプトを読み込む時にfopenを使います。しかし、AndroidのAPKのassetsフォルダはfopenでアクセスできません。独自のファイルシステムを構築したい場合もあります。

そういう時は、以下のようにして、標準のdofileを上書きしてファイルシステムを置き換えます。

	int aflDoFileForReplace(lua_State* L)
	{
	const char* fileName = lua_tostring(L, -1);
	char* img = (char*)LoadFile(fileName);
	if (!img) {
	luaL_error(L, "aflDoFile: could not load file %s", fileName);
	return false;
	}
	bool ok = true;
	if (luaL_loadbuffer(L, img, strlen(img), fileName)) {
	luaL_error(L, "luaL_loadbuffer failed!\n%s", lua_tostring(L, -1));
	lua_pop(L, 1);
	ok = false;
	}
	free(img);
	if (ok && lua_pcall(L, 0, LUA_MULTRET, 0)) {
	luaL_error(L, "lua_pcall failed!\n%s", lua_tostring(L, -1));
	lua_pop(L, 1);
	ok = false;
	}
	return lua_gettop(L) - 1;
	}
	void ReplaceDoFile(lua_State* L)
	{
	lua_register(L, "dofile", aflDoFileForReplace);
	}

view raw replace_dofile.cpp hosted with ❤ by GitHub

LoadFile関数はファイル名を受け取ってmallocで確保したメモリブロックにファイルの内容を格納して返すようにしました。例えばAndroidの場合はassetsフォルダからファイルを持ってくるようにします。このエントリを参考にしてください。

luaL_loadbuffer関数にスクリプトの内容とファイル名を渡します。ファイル名は万一スクリプト内でエラーが発生した場合にLuaがどのファイルの何行目なのかを知らせてくれる為に重要です。

lua_pcallは、読み込んだスクリプトを一度「実行」します。Cのような言語と違い、Luaは関数や変数の定義も「実行」することで行われますので、これをしないとスクリプトを読み込まなかったのと同じことになります。

luaL_loadbuffer又はlua_pcallでエラーが発生した場合、Luaスタックの最上位にエラーメッセージが入ります。ここでは、適当にメッセージを加工してluaL_errorに渡します。これによって、dofileの呼び出し元のスクリプト側のエラーとして処理されます。

最後のreturn lua_gettop(L) - 1;lua_pcallがスタック何かを積んだ場合、その個数を呼び出し元に返します。-1するのはdofileが受け取ったファイル名がスタックを一つ使っているのでそれを除外するためです。説明より実例のほうがわかりやすいと思うので、以下に書いてみました。例えば、以下のような事ができるようになります。

return "A message from callee!"

view raw callee.lua hosted with ❤ by GitHub

	local a = dofile("callee.lua")
	print(a)

view raw caller.lua hosted with ❤ by GitHub

呼びだされたcallee.luaの最後の行にreturn文があり、その戻り値をcaller.luaで受け取っています。こういった使い方が必要ない場合は、return lua_gettop(L) - 1;はreturn 0;に置き換えても不都合はありません。ただし、caller.luaはdofileから戻り値を受け取れなくなります。

Windows 10でDirectX12のWARPデバイスの生成が失敗する時の処方箋

DirectX12対応ビデオカードを保有していなくてもWindows10だけでDirectX12のプログラムをテストできるWARPデバイスというものがあります。

GitHubで配布されているMicrosoftのサンプルプログラムであるDirectX-Graphics-Samplesに含まれるサンプルは、-warpというコマンドライン引数を渡すとWARPデバイスで実行できます。この時にOutputDebugStringでこんなエラーが出て失敗します。

D3D12GetDebugInterface: This method requires the D3D12 SDK Layers for Windows 10, but they are not present on the system.

また、DirectX11で、D3D11_CREATE_DEVICE_DEBUGを指定した場合も以下のエラーが出ていました。

D3D11CreateDevice: Flags (0x2) were specified which require the D3D11 SDK Layers for Windows 10, but they are not present on the system.

これは、Graphics Tools for Windows 10を入れることで解決します。以下のようにたどってインストールします。

あるいは、管理者権限で以下のコマンドを入力するといいようです。

Dism /online /add-capability /capabilityname:Tools.Graphics.DirectX~~~~0.0.1.0

参考：

1. http://stackoverflow.com/questions/32809169/use-d3d11-debug-layer-with-vs2013-on-windows-10
2. https://msdn.microsoft.com/en-us/library/mt125501.aspx#InstallGraphicsTools
3. http://blogs.msdn.com/b/vcblog/archive/2015/03/31/visual-studio-2015-and-graphics-tools-for-windows-10.aspx

Upgrade可能なReaders–Writer Lock を自前で実装する

Readers–writer lockとは、複数のスレッドの同時リードは許可するが、ライトする場合は他のスレッドのリードとライトをすべて排除するというものです。

C++14でshared_timed_mutexがstdに含まれましたが、リードからライトへ昇格(Upgrade)はサポートされませんでした。

実は昇格も比較的簡単に自前で実装できます。C++11以降はstd::threadやstd::atomicなど、スレッドに関する機能が大幅に強化されているので、これらを使って昇格可能なロックを実装してみます。

基本のロック

	class Atomic {
	std::atomic<int> val = 0;
	public:
	void Lock()
	{
	int expected = 0;
	while (!val.compare_exchange_weak(expected, 1)) {
	expected = 0;
	}
	}
	void Unlock()
	{
	val.exchange(0);
	}
	};

view raw spin_lock.cpp hosted with ❤ by GitHub

std::atomicを使います。0ならロックされていない状態、1ならロック状態です。Lockを呼んだ時点ですでにロックされていたらその場でループして待ちます。

compare_exchange_weakというのは、いわゆる"Compare and Swap"、略してCASと呼ばれます。比較と交換を１命令で行う、マルチスレッドの実装に必須の命令です。

whileでループしているので、ロック取得の待機中はCPU時間を消費します。この方式をスピンロックといいます。比較的短時間のロックは効率的ですが、ロック時間が長くなると無駄が生じる特性ががあります。今回の記事はすべてスピンロックで実装しました。

最も簡単なreaders-writer lock

リードロックとライトロックを分けた実装です。リードロックは複数スレッドから同時に可能で、ライトは１つのスレッドから可能です。

	class Atomic {
	std::atomic<int> val = 0;
	static const int writeLockBit = 0x40000000;
	void LockInternal(int delta, int testBits)
	{
	int expected;
	do {
	do {
	expected = val;
	} while (expected & testBits);
	} while (!val.compare_exchange_weak(expected, expected + delta));
	}
	public:
	void ReadLock() { LockInternal(1, writeLockBit); }
	void ReadUnlock() { val.fetch_sub(1); }
	void WriteLock() { LockInternal(writeLockBit, 0xffffffff); }
	void WriteUnlock() { val.fetch_sub(writeLockBit); }
	};

view raw readers_writer_lock.cpp hosted with ❤ by GitHub

val変数の0x40000000ビットをライトロックの為に使い、それより下のビットはリードロックの個数を記録するカウンタとして動作します。

LockInternal関数がポイントで、valの中にtestBitと被るビットがある間は待機し、testBitと被らなくなったらdeltaをvalに加算します。この関数に渡す数値の組み合わせだけでリードロックとライトロックが実現できます。

これを表にするとこうなります。

ステート移動	立てるビット	待機するビット
アイドル→リード	リード	ライト
アイドル→ライト	ライト	リード、ライト

昇格可能なreaders-writer lock

リードロックからライトロックへの昇格を実装してみます。実は「昇格」をどう定義するかで実装が変わってしまうのですが、以下は実装の一例です。

	class Atomic {
	std::atomic<int> val = 0;
	static const int writeLockBit = 0x40000000;
	static const int upgradingBit = 0x00010000;
	static const int writeUpgradeingBits = 0x7fff0000;
	static const int readerBits = 0x0000ffff;
	void LockInternal(int delta, int testBits)
	{
	int expected;
	do {
	do {
	expected = val;
	} while (expected & testBits);
	} while (!val.compare_exchange_weak(expected, expected + delta));
	}
	public:
	void ReadLock() { LockInternal(1, writeUpgradeingBits); }
	void ReadUnlock() { val.fetch_sub(1); }
	void WriteLock() { LockInternal(writeLockBit, readerBits | writeLockBit); }
	void WriteUnlock() { val.fetch_sub(writeLockBit); }
	void Upgrade()
	{
	val.fetch_add(upgradingBit - 1);
	LockInternal(writeLockBit - upgradingBit, readerBits | writeLockBit);
	}
	};

view raw upgradable_readers_writer_lock.cpp hosted with ❤ by GitHub

実はUpgrade関数の内部で「昇格中」という別のステートが存在しています。

ステート移動	立てるビット	待機するビット
アイドル→リード	リード	ライト、昇格中
アイドル→ライト	ライト	リード、ライト
アイドル→昇格中	昇格中	無し

なぜ「昇格中」ステートが必要かを説明します。

ライトロック取得の為には他の全てのスレッドのリードロックの解除を待ちます。しかし、リードからライトに移行しようとする複数のスレッドがある時デッドロックが発生することになります。なぜならお互いがリードロックを手放さずに待ち続けているためです。

ここで、「昇格中」というステートを設けます。このステートに入ることで、自身のリードロックを解除し、他のスレッドのリードロックの解除も待ちます。すると残るのは「昇格中」ステートを持つスレッドのみになるので、順次ライトロックを取得できるようになります。

この方法は、デッドロックを避ける事ができますが、「Upgrade関数実行中」に他のスレッドがライトロックを取得できてしまうという欠点があります。Upgrade関数呼び出しの前後でロック対象のデータが変更されている可能性があるわけです。

リードロックを昇格可能なものと不可能なものに分けたreaders-writer lock

昇格の前後でデータが変更されたくない場合、「昇格可能な特殊なリードロックは一つだけ取得可能」とする方法があります。boostのupgrade_lockの実装のようなものです。

	class Atomic {
	std::atomic<int> val = 0;
	static const int writeLockBit = 0x40000000;
	static const int upgradableBit = 0x00010000;
	static const int readerBits = 0x0000ffff;
	void LockInternal(int delta, int testBits)
	{
	int expected;
	do {
	do {
	expected = val;
	} while (expected & testBits);
	} while (!val.compare_exchange_weak(expected, expected + delta));
	}
	public:
	void ReadLock() { LockInternal(1, writeLockBit); }
	void ReadUnlock() { val.fetch_sub(1); }
	void ReadLockUpgradable() { LockInternal(upgradableBit, writeLockBit | upgradableBit); }
	void ReadUnlockUpgradable() { val.fetch_sub(upgradableBit); }
	void Upgrade() { LockInternal(writeLockBit - upgradableBit, readerBits | writeLockBit); }
	void WriteLock() { LockInternal(writeLockBit, readerBits | writeLockBit); }
	void WriteUnlock() { val.fetch_sub(writeLockBit); }
	};

view raw upgradable_read_lock.cpp hosted with ❤ by GitHub

リードロックはReadLock/ReadUnlockの組、昇格可能なリードロックはReadLockUpgradable/ReadUnlockUpgradableの組で取得します。

ReadLockUpgradableでロックを取得した場合、他のスレッドからのReadLockを妨げずに共存しますが、他のスレッドからReadLockUpgradableを同時に取得することはできません。１つのスレッドだけがReadLockUpgradableを取れるので、Upgradeの段階で競合が発生しないことと、Upgrade中に他のスレッドがライトロックを取得したりしないことが保障されます。

ステート移動	立てるビット	待機するビット
アイドル→リード	リード	ライト
アイドル→ライト	ライト	全ビット
アイドル→昇格可能リード	昇格可能リード	ライト、昇格可能リード

リードロックを途切れなくライトロックに昇格可能、ただし失敗付き

全てのリードロックを昇格可能にしたいけれど、Upgrade中に別のWriteLockに割り込まれたくない場合の実装です。代償として、昇格の関数名がTryUpgradeとなっており、昇格が失敗する場合があります。

なぜ失敗するかというと、途切れない昇格を実現するために昇格中にリードロックを手放さないためです。二つ以上のスレッドが同時に昇格しようとするとお互いのリードロック解放を待つためにデッドロックします。そこで、最初に昇格しようとしたスレッドのみ昇格に成功させることにします。

万が一昇格に失敗した場合、次に出来ることはリードロックを解除することだけです。もし、どうしてもライトロックが欲しければ一度リードロックも解除して他のスレッドにライトロックを譲った後、改めてライトロックの取得を試みるしかありません。

この手法の短所は利用者が例外処理を書かなければならず、ただでさえバグを入れやすいマルチスレッド処理の実装がより複雑化しやすい事です。

	class Atomic {
	std::atomic<int> val = 0;
	static const int writeLockBit = 0x40000000;
	static const int upgradingBit = 0x20000000;
	static const int readerBits = 0x0000ffff;
	void LockInternal(int delta, int testBits)
	{
	int expected;
	do {
	do {
	expected = val;
	} while (expected & testBits);
	} while (!val.compare_exchange_weak(expected, expected + delta));
	}
	public:
	void ReadLock() { LockInternal(1, writeLockBit | upgradingBit); }
	void ReadUnlock() { val.fetch_sub(1); }
	void WriteLock() { LockInternal(writeLockBit, 0xffffffff); }
	void WriteUnlock() { val.fetch_sub(writeLockBit); }
	bool TryUpgrade()
	{
	int expected;
	do {
	expected = val;
	if (expected & upgradingBit) {
	return false;
	}
	} while (!val.compare_exchange_weak(expected, expected | upgradingBit));
	LockInternal(writeLockBit - upgradingBit - 1, writeLockBit | (readerBits & ~1));
	return true;
	}
	};

view raw try_upgrade_spin_lock.cpp hosted with ❤ by GitHub

TryUpgrade関数のwhileループで昇格中ステートへの移行を試みます。他のスレッドに先に昇格中ビットを立てられた場合は失敗します。

自身によって昇格中ビットを立てることに成功すればLockInternalでライトステートへ移行します。readerBitsの最下位ビットを待機対象から除外するのは、自身がリードロックを持っているためリードロックのカウンタが1の時は通過させなければいけないためです。

ステート移動	立てるビット	待機するビット	備考
アイドル→リード	リード	ライト、昇格中
アイドル→ライト	ライト	全ビット
リード→昇格中	昇格中	無し	他のスレッドが昇格中ビットを取得したら失敗
昇格中→ライト	ライト	ライト、リード	リードロックの１つは自分が持っているので、最下位ビットを待機対象から除外

まとめ

リードロックからライトロックへの昇格が比較的簡単に実装できることがわかりましたが、問題は昇格の方式が色々あって、しかも一長一短があるために標準化しにくいということでした。

素直に昇格はあきらめてshared_timed_mutexで満足するのも手かもしれませんし、boostやIntel TBB等の有名なライブラリを使う場合はそのライブラリで提供された昇格機能に限って使うことにしてもいいかもしれません。

テストに使ったGitHubレポジトリ
https://github.com/yorung/ThreadTest

DDS自力ロード(Cube Map, Mipmap, DXT1, DXT3, DXT5対応)

Windows10が提供されて誰でもDirectX12による開発ができるようになりました。しかし、DirectXTKやDirectXTexのようなテクスチャのロードが出来るライブラリがまだマイクロソフトから提供されていないようです。DDSは特に複雑なフォーマットではないはずなので、DX12の準備を兼ねて自力でロードを試みてみます。ただし、DirectX11です。（DX12も対応しました。）

以下でほぼ全部です。キューブマップ、ミップマップ、圧縮/非圧縮すべて対応しています。エラーチェックはちゃんとしていないので壊れたファイルや未対応の形式でバッファーオーバーランなどの危険があるかもしれません。

	struct DDSHeader {
	uint32_t h3[3];
	int h, w;
	uint32_t h2[2];
	int mipCnt;
	uint32_t h13[13];
	uint32_t fourcc, bitsPerPixel, rMask, gMask, bMask, aMask, caps1, caps2;
	bool IsCubeMap() const { return caps2 == 0xFE00; }
	int GetArraySize() const { return IsCubeMap() ? 6 : 1; }
	int GetMipCnt() const { return std::max(mipCnt, 1); }
	};
	static void ArrangeRawDDS(void* img, int size)
	{
	const DDSHeader* hdr = (DDSHeader*)img;
	DWORD rShift, gShift, bShift, aShift;
	_BitScanForward(&rShift, hdr->rMask);
	_BitScanForward(&gShift, hdr->gMask);
	_BitScanForward(&bShift, hdr->bMask);
	_BitScanForward(&aShift, hdr->aMask);
	std::for_each((uint32_t*)img + 128 / 4, (uint32_t*)img + size / 4, [&](uint32_t& im) {
	im = ((hdr->aMask & im) >> aShift << 24) + ((hdr->bMask & im) >> bShift << 16) + ((hdr->gMask & im) >> gShift << 8) + ((hdr->rMask & im) >> rShift);
	} );
	}
	static ComPtr<ID3D11ShaderResourceView> LoadDDSTexture(const char* name, ivec2& texSize)
	{
	int size;
	ComPtr<ID3D11ShaderResourceView> srv;
	void* img = LoadFile(name, &size);
	if (!img) {
	aflog("LoadDDSTexture failed! %s", name);
	return 0;
	}
	const DDSHeader* hdr = (DDSHeader*)img;
	DXGI_FORMAT format;
	int (*pitchCalcurator)(int, int) = nullptr;
	switch (hdr->fourcc) {
	case 0x31545844: //'1TXD':
	format = DXGI_FORMAT_BC1_UNORM;
	pitchCalcurator = [](int w, int h) { return ((w + 3) / 4) * ((h + 3) / 4) * 8; };
	break;
	case 0x33545844: //'3TXD':
	format = DXGI_FORMAT_BC2_UNORM;
	pitchCalcurator = [](int w, int h) { return ((w + 3) / 4) * ((h + 3) / 4) * 16; };
	break;
	case 0x35545844: //'5TXD':
	format = DXGI_FORMAT_BC3_UNORM;
	pitchCalcurator = [](int w, int h) { return ((w + 3) / 4) * ((h + 3) / 4) * 16; };
	break;
	default:
	ArrangeRawDDS(img, size);
	format = DXGI_FORMAT_R8G8B8A8_UNORM;
	pitchCalcurator = [](int w, int h) { return w * h * 4; };
	break;
	}
	texSize.x = hdr->w;
	texSize.y = hdr->h;
	int arraySize = hdr->GetArraySize();
	int mipCnt = hdr->GetMipCnt();
	CD3D11_TEXTURE2D_DESC desc(format, hdr->w, hdr->h, arraySize, hdr->GetMipCnt(), D3D11_BIND_SHADER_RESOURCE, D3D11_USAGE_DEFAULT, 0, 1, 0, hdr->IsCubeMap() ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0);
	CD3D11_SHADER_RESOURCE_VIEW_DESC srvDesc(hdr->IsCubeMap() ? D3D_SRV_DIMENSION_TEXTURECUBE : D3D_SRV_DIMENSION_TEXTURE2D, desc.Format, 0, -1);
	std::vector<D3D11_SUBRESOURCE_DATA> r;
	int offset = 128;
	for (int a = 0; a < arraySize; a++) {
	for (int m = 0; m < mipCnt; m++) {
	int w = std::max(1, hdr->w >> m);
	int h = std::max(1, hdr->h >> m);
	r.push_back({ (char*)img + offset, (uint32_t)pitchCalcurator(w, 1), 0 });
	offset += pitchCalcurator(w, h);
	}
	}
	ComPtr<ID3D11Texture2D> tex;
	deviceMan11.GetDevice()->CreateTexture2D(&desc, &r[0], &tex);
	deviceMan11.GetDevice()->CreateShaderResourceView(tex.Get(), &srvDesc, &srv);
	free(img);
	return srv;
	}

view raw dds_loader.cpp hosted with ❤ by GitHub

ID3D11Texture2DとDDSファイルは共にキューブマップやミップマップの複数のイメージを内包します。よって、DDSからそれらを含むID3D11Texture2Dを生成するときにD3D11_SUBRESOURCE_DATAの配列でその複数イメージを指定します。

ミップマップ入りキューブマップ等になるとD3D11_SUBRESOURCE_DATAの順で悩みそうですが、これはIntroduction To Textures in Direct3D 11が詳しいです。更に都合のよいことに、D3D11_SUBRESOURCE_DATAとDDSの画像の配列順は同じになっているようです。

また、各画像の開始位置を正確にD3D11_SUBRESOURCE_DATAに設定しなければいけませんが、テクスチャ用の DDS ファイルのレイアウトと題されたページが参考になります。

やってみると意外と短いコードで出来たので紹介してみました。

HLSLでフォトスフィアをLittle Planetに変換する

スマホで撮った近所の公園のフォトスフィアからLittle PlanetとかTiny Planetと呼ばれている絵ができました。

ソース画像となるフォトスフィアとはGoogleによる呼称で、「360度パノラマVR」と呼ばれたり「全方位パノラマ」と呼ばれたり呼称が統一されていない様です。最近は「HDRi」で検索すると海外の素材集がいっぱいでてきますね。投影法はEquirectangular Projection（正距円筒図法）といいます。ここではフォトスフィアで統一します。

また、結果物であるLittle Planetのような投影法をStereographic Projection（ステレオ投影）といいます。

今回の目的は、HLSLによってEquirectangular Projectionされた画像をソースとしてStereographic Projectionした画像を得ることです。 まず、簡単のためにキューブマップをソースにしてやってみます。

	float4 mainPS(VsToPs inp) : SV_Target
	{
	float2 scale = float2(4.0f / 3.0f, 1) * 3; // scale & aspect ratio
	float2 plane = inp.screenPos.xy * scale;
	float3 dir = float3(plane.x * 2, plane.y * 2, -1 + dot(plane, plane)) / (1 + dot(plane, plane));
	return texCube.Sample(samplerState, dir.xzy); // y is upper
	}

view raw little_planet.hlsl hosted with ❤ by GitHub

scaleはアスペクト比と、Little Planetの大きさを決めます。ここは見た目が良くなるように適当に数値を決めればよいところです。
キューブマップのフェッチに使うdirはWikipediaのステレオ投影で紹介されている立体射影の逆写像の式そのままです。実際にフェッチの段階でyとzを入れ替えるのは、キューブマップのY方向が上下になっているからです。どうスィズルするかによってLittle Planetの中心をどこにするか決められます。

次に、フォトスフィアをソースにしてやってみます。冒頭の絵はこれで生成します。

	float4 mainPS(VsToPs inp) : SV_Target
	{
	float2 scale = float2(4.0f / 3.0f, 1) * 3; // scale & aspect ratio
	float2 plane = inp.screenPos.xy * scale;
	float3 dir = float3(plane.x * 2, plane.y * 2, -1 + dot(plane, plane)) / (1 + dot(plane, plane));
	dir = dir.xzy; // y is upper
	float longitude = atan2(dir.x, dir.z) * (180 / 3.14159265f);
	float latitude = asin(dir.y) * (180 / 3.14159265f);
	return gTexture.Sample(samplerState, float2(longitude, latitude) / float2(360, -180) + 0.5);
	}

view raw projection_equirectangular_to_stereographic.fx hosted with ❤ by GitHub

前半部はキューブマップと全く同じで、dirを使ってフォトスフィアのどこからフェッチするかの計算が加わりました。まず、三次元ベクトルのdirを経度（longitude、-180～180）と緯度（latitude、-90～90）に変換します。そうすると経度と緯度がフォトスフィアのX方向とY方向に対応します。あとはテクスチャUVである0～1の範囲に変換すれば完成です。

Visual Studio 2015でCとJavaを併用したAndroidサンプル、Target API Levelの変更方法

https://code.msdn.microsoft.com/windowsdesktop/hello-jni-Android-790ab73d

JavaからActivityを作り、Cから文字列を生成してTextViewに表示するプログラムがMicrosoftから公開されています。Android NDKに含まれているhello-jniサンプルと同じもので、Visual Studio 2015のプロジェクトファイルが含まれています。

KitKat用にビルドされる設定になっていたのでうちの古い機種(Vega Racer)で動かす為にTarget API Levelを下げてみました。https://developer.android.com/about/dashboards/index.html によるとGingerbreadが4.6%ほどしぶとく残っていたので、Gingerbreadまで下げてみます。

プロジェクトのプロパティと、hello-jni.Packaging というファイルのプロパティの２箇所に設定があって、それぞれDebug/Releaseと、ARM/x86の組み合わせに対してTarget API Levelを設定します。（８箇所！）PackagingのほうはAndroid SDK Managerdで該当のAPIをダウンロードしておかないと選択肢が出てきませんでした。

古いAndroid実機でF5で実行しようとすると、"Unable to start debugging. The Visual Studio C++ Android debugger requires that the target emulator/device be running Android API level 17 (version 4.2) or newer."のメッセージが出ました。この場合でもCtrl-F5でデバッグ無しで実行できました。

Visual Studio 2015からAndroid(+OpenGL ES)開発

Visual Studio 2015でAndroidが開発できるとのことで試してみました。OpenGL ESもちゃんと動きました。

インストールオプションは適当です。

新規プロジェクト画面。インストール時に何かが抜けていたのか、Android開発ツールの追加インストール画面へのリンクが表示されています。

追加インストール画面。

Android用のテンプレートが追加されました。OpenGLESによるAndroidとiOSのクロスプラットフォームのテンプレートがあります。

WindowsからiOSが開発できるのかと期待しましたが、結論から言うと残念ながらMacが別途必要のようです。

https://msdn.microsoft.com/en-US/library/mt147405.aspx

http://stackoverflow.com/questions/31843957/vs2015-build-agent-request-has-failed-uri-not-set

テンプレートからプロジェクトを生成してビルドすると、"Build agent request has failed, URI not set..."というiOS関連のエラーが出ました。*.iOS.StaticLibrary(iOS)と*.iOS.Applicationプロジェクトを削除するとAndroidの開発環境だけが残りました。

ところで、Visual Studioが認識するデバイスとしないデバイスがあるようです。Vega RacerとAcer Iconiaは認識しました。LG GFlex2は認識せず、"No devices available"と表示されます。GFlex2はadb devicesではちゃんと認識しており、Android Studioからのデバッグも問題がなかったのでadb以外の他の原因がありそうです。

また、認識した２機種も"No devices available."と出る時がありました。少し待てば認識されることもありましたが、プロジェクトを閉じて開き直すと認識することもありました。

ACER ICONIAはx86なのですが、armeabiと表示がでているのはバグでしょうか。左のプルダウンメニューからARMかx86かを選んでデバッグするようになっており、正しいアーキテクチャを指定すれば実行できました。

[slide]프로그래머를 위한 360VR

로드뷰, 360VR의 기반 기술인 Equirectangular Projection(이퀴렉탱귤러/등장방형도법)을 이해해, DirectX11과 HLSL로 화면 출력, 큐브맵과 상호 변환 방법을 공부합니다.

HLSLでフォトスフィアビューアを作る

ストリートビューなどで使われ、最近はAndroidのカメラなどでも誰でも手軽に作れるようになったフォトスフィアをDirectX11とHLSLでレンダリングしてみます。全方向の色を記録するためEquirectangular projectionという投影方法で長方形になっています。世界地図などでは正距円筒図法と呼ばれるようです。



これにPhoto Sphere XMP Metadataと呼ばれるメタデータが埋まることで、対応アプリから認識されます。非対応アプリからは普通のJPGファイルです。

全方向画像と言えば、ゲーム開発で主に使われるのはcube mapです。実際、cube mapで遠景を描いているゲームも多いと思いますが、フォトスフィアビューアでやる事とほとんど同じです。各シェーダの全文の例を掲示します。何をしているかというと、各ピクセルの視線ベクトルを求め、その方向の色をcubemap又はPhoto Sphereから読み取っています。見ての通り頂点シェーダ(mainVS)からピクセルシェーダ(mainPS)の第一行目まで全く同じです。

	cbuffer perObject : register(b0)
	{
	row_major matrix invVP;
	}
	TextureCube texCube : register(t0);
	SamplerState samplerState : register(s0);
	struct VsToPs
	{
	float4 pos : SV_POSITION;
	float4 pos2 : POS2;
	};
	VsToPs mainVS(uint id : SV_VertexID)
	{
	VsToPs ret;
	ret.pos = float4(id & 1 ? 1 : -1, id & 2 ? -1 : 1, 1, 1);
	ret.pos2 = ret.pos;
	return ret;
	}
	float4 mainPS(VsToPs inp) : SV_Target
	{
	float3 dir = normalize(mul(inp.pos2, invVP).xyz);
	return texCube.Sample(samplerState, dir);
	}

view raw cubemap.hlsl hosted with ❤ by GitHub

	cbuffer perObject : register(b0)
	{
	row_major matrix invVP;
	}
	Texture2D gTexture : register(t0);
	SamplerState samplerState : register(s0);
	struct VsToPs
	{
	float4 pos : SV_POSITION;
	float4 pos2 : POS2;
	};
	VsToPs mainVS(uint id : SV_VertexID)
	{
	VsToPs ret;
	ret.pos = float4(id & 1 ? 1 : -1, id & 2 ? -1 : 1, 1, 1);
	ret.pos2 = ret.pos;
	return ret;
	}
	float4 mainPS(VsToPs inp) : SV_Target
	{
	float3 dir = normalize(mul(inp.pos2, invVP).xyz);
	float coordX = atan2(dir.x, dir.z) / 3.1415926;
	float coordY = asin(dir.y) / (3.1415926 / 2);
	return gTexture.Sample(samplerState, float2(coordX, coordY) * float2(0.5, -0.5) + 0.5);
	}

view raw photosphere.hlsl hosted with ❤ by GitHub

C++からは頂点は４つ出力しています。頂点バッファをバインドしない代わりに頂点シェーダで画面の四隅の位置を設定して全画面を塗りつぶします。また、pos2をラスタライザに渡してピクセルシェーダからピクセルの画面上の位置を取得できるようにします。ピクセルシェーダの一行目で画面上の位置にinvVPを掛けることで画角とカメラの方向が反映された視線方向を求められます。invVPはView行列とProjection行列を掛けたものの逆行列です。

ここから先はcube mapとphotosphereで処理が変わりますが、キューブマップの場合は視線ベクトルから色を求めるのはたったの１行です。キューブマップは元々三次元ベクトルから色を取得するものなので当然ですね。それに対し、Photo Sphereは三次元ベクトルをEquirectangularで投影した二次元テクスチャの座標に変換する作業が間に入ります。

このプログラムの三次元の座標系は、右が+x、上が+y、奥が+zと定義しています。フォトスフィア上の二次元の座標系coordX, coordYは、フォトスフィアの中心を(0,0)とし、左上を(-1,-1) 右下を(+1,+1)と定義します。便宜上の定義であって実際のテクスチャの座標ではないことに注意してください。



写真だと位置をイメージしにくいので、Equirectangular projectionされた世界地図を使って、実例で座標を指定してみます。
東経0度、北緯0度 =(0, 0)、ガーナ南方の赤道上の地点、ここは視線ベクトル(0, 0, 1)になります。
東経0度、北緯45度 =(0, 0.5)、フランスのボルドー、ここは視線ベクトルは(0, 0.7071, 0.7071)です。
西経90度、北緯45度 =(-0.5, 0.5) ウィスコンシン州、ここは視線ベクトルは(-0.7071, 0.7071, 0)です。

こうして数値を見比べてみると数式が見えてこないでしょうか。
coordXは視線ベクトルのうちy成分を無視して、xとzからatan2で角度を求めればそれがそのまま経度になります。
coordYは視線ベクトルy成分からのみ算出します。どちらも-1から1の範囲ですが、経度は球面上の距離なのでasinで変換します。

最後に、coordX, coordYは実際のテクスチャ座標系ではないので0から1の範囲に変換してテクスチャを読み込みます。

OpenGL ESのextensionを機種別に簡単に確認できるページ

http://www.gpuinfo.org/
知る限り、最も使いやすそうなページ。機種別のエクステンションはもちろん、エクステンションに対応した機種を一覧にして見られます。OpenGL ES CapsViewerというアプリで取得した情報をこのサイトにアップロードできます。Androidのみ対応のようです。

最近ではESではないOpenGL、Vulkanにも対応しています。Vulkan用のAndroidアプリはHardware CapsViewer for Vulkanで、同様に端末のVulkanのスペックをアップロードできるようになっています。
(2017/11/5 URLを更新、OpenGLとVulkanへの対応した旨を追記)

https://gfxbench.com/result.jsp
Android, iOSはもちろん、PCやOSXのOpenGLの結果も見られます。GFXBenchというベンチマークのサイトで、extensionはちょっと見つけにくい場所にあります。各機種の結果ページのInfoタブの3D APIに下向きの三角形のボタンがあり、そこを押すとextensionが見られます。

OpenGL ES 2.0でhalf float textureは使えるか？

結論から書くと、QualcommのAdrenoならいけるかもしれません。でもhalf float textureはOpenGL ES 3.0以上でしか使わないと決めてしまったほうがよさそうです。

ES 2.0におけるhalf float textureはextension扱いになり、OES_texture_half_floatがあれば使えます。OpenGL ES 2.0とOpenGL ES 3.0でglTexImage2Dのパラメータが違うのが面倒ですが、以下のように分岐すればいいだけなので、生成そのものは難しくありません。

	#ifdef OPENGL_OR_ES30
	// ES 3.0
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, w, h, 0, GL_RGBA, GL_HALF_FLOAT, nullptr);
	#else
	// ES 2.0
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_HALF_FLOAT_OES, nullptr);
	#endif

view raw half_float_texture.cpp hosted with ❤ by GitHub

問題は、OES_texture_half_floatはhalf float textureの生成を保証するだけで、half float textureに対するレンダリングまで保証しない事です。half float textureへのレンダリングは EXT_color_buffer_half_float という別のextensionあれば可能になるようです。

http://stackoverflow.com/questions/8621095/how-to-use-gl-half-float-oes-typed-textures-in-ios

これは、PowerVR SGX 544MP2搭載のAcer Iconia B1-730HD タブレットではその通りになりました。OES_texture_half_floatはあってEXT_color_buffer_half_floatが無い為か、glDrawElementsの段階でGL_INVALID_FRAMEBUFFER_OPERATIONというエラーを出しました。しかし、EXT_color_buffer_half_floatが存在しない手元のAdreno 220(IM-A770K)ではhalf float textureにレンダリングが出来たり、ちぐはぐなことになっています。

また、ES 2.0のARM Mali GPUの場合はOES_texture_half_floatそのものが無いようです。

extensionを見て切り分けができないのは困ったことです。しかしそれ以上にhalf float textureの用途はレンダーターゲットが大部分だと思うので、OES_texture_half_floatという拡張名を見て「OpenGL ES 2.0でhalf float textureにレンダリング出来る！」と思ったプログラマが貴重な時間を空転させてしまうのが最も大きな問題ではないかと思う次第です。

ただし、OpenGL ES 2.0時代のGPUは帯域幅も非力なので、仮にhalf float textureにレンダリングできたとしても効果を活かせる程凝ったことができなかったかもしれません。

OpenGL ES 2.0のglBindAttribLocationと、ES 3.0のInput Layout Qualifiers

OpenGL ES 3.0以降では、GLSLから頂点属性の入力位置をlayoutから始まる構文で指定することが出来ます。これをKhronosの公式文書ではInput Layout Qualifiersと呼んでいます。

	#version 310 es
	layout(location = 0) in vec3 position;
	layout(location = 1) in vec3 normal;

view raw layout_location.glsl hosted with ❤ by GitHub

OpenGL ES 2.0の場合はInput Layout Qualifiersが無いのでGLSLにlocationを記述できませんが、glBindAttribLocationでC側から同じ事ができます。glLinkProgramの直前にglBindAttribLocationを使って頂点属性の名前とlocationを任意に指定できます。

	static const int POSITION_INDEX = 0;
	static const int NORMAL_INDEX = 1;
	glBindAttribLocation(program, POSITION_INDEX, "position");
	glBindAttribLocation(program, NORMAL_INDEX, "normal");
	glLinkProgram(program);

view raw how_to_bind.cpp hosted with ❤ by GitHub

	#version 100
	attribute vec3 position;
	attribute vec3 normal;

view raw no_layout.glsl hosted with ❤ by GitHub

ただし、Input Layout Qualifiersを使う場合Cはlocationの番号だけ知っていればよいのに対し、glBindAttribLocationを使うと名前と番号の両方をCから指定するので冗長な感じがします。

GLSLでlocationを指定せず、glBindAttribLocationもしないとglLinkProgramの時点で自動的にlocationが振り分けられます。この場合、glGetAttribLocationでlocationを問い合わせる必要があります。

	GLint positionIndex = glGetAttribLocation(program, "position");
	GLint normalIndex = glGetAttribLocation(program, "normal");

view raw query.cpp hosted with ❤ by GitHub

こうするとES2.0でもES3.0でも動く上、名前のみで頂点attributeを結び付けられる為に分かり易いという利点があります。いいことずくめのようですが、locationの割り当てが実装依存で予想できない為、複数シェーダでlocationを共有できないという欠点があります。同じ頂点バッファを複数のシェーダで描画する場合、シェーダを切り替える毎にglGetAttribLocationで問い合わせる煩雑さがあります。

この煩雑さはES 3.0でVAO(Vertex Array Object)を使いはじめると特に顕著です。シェーダ毎にlocationが異なるとVAOをシェーダー毎に作り直さなければいけません。一つのVAOを複数のシェーダで使いまわす為にはlocationの番号を固定する必要があります。

ある程度の規模のフレームワークを作ることを考えると、glBindAttribLocationかInput Layout Qualifiersを使い、"position"は0番、"normal"は1番などと、あらかじめlocationを決めておくとうまく書けそうです。

(2016/03/29 追記)
使いやすいフレームワークのためのもっといい方法を思いついたので書きました。
http://glhub.blogspot.kr/2016/03/opengldirectx.html

Android NDKでC++11のstd::chronoを使った時間計測

今まで以下のような秒単位の時間計測関数を、Android用とWindows用にそれぞれ作って使っていました。

	double GetTime()
	{
	timespec t;
	clock_gettime(CLOCK_MONOTONIC, &t);
	return (double)t.tv_sec + (double)t.tv_nsec / 1000000000;
	}

view raw get_time_android.cpp hosted with ❤ by GitHub

	double GetTime()
	{
	LARGE_INTEGER t, f;
	QueryPerformanceCounter(&t);
	QueryPerformanceFrequency(&f);
	return (double)t.QuadPart / f.QuadPart;
	}

view raw get_time_win.cpp hosted with ❤ by GitHub

今更ながら、C++11のstd::chronoでどちらでも動く関数を書けることに気づき、以下のように書きなおしました。

	#include <chrono>
	double GetTime()
	{
	static auto start = std::chrono::high_resolution_clock::now();
	auto now = std::chrono::high_resolution_clock::now();
	return std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1, 1>>>(now - start).count();
	}

view raw get_time.cpp hosted with ❤ by GitHub

static auto startが妙ですが、こうするとGetTimeの初回呼び出し時の時間をstartに記録できます。あとは毎回のGetTimeの呼び出しでstartからの経過時間を秒単位で返します。

#include <chrono> で "fatal error: chrono: No such file or directory"というエラーが出てしまう場合、build.gradleでgnustlを使うよう設定する必要があります。build.gradleの一部を抜粋します。

	android {
	defaultConfig {
	ndk {
	moduleName 'AdamasNative'
	cFlags "-std=c++11"
	ldLibs "log"
	ldLibs "GLESv3"
	abiFilters "armeabi", "mips", "x86"
	stl "gnustl_static"
	}
	}
	}

view raw build.gradle hosted with ❤ by GitHub

"stlport_static"ではだめで、"gnustl_static"を使う必要があるようです。android-ndk-r10d\sources\cxx-stl\stlport\stlportにはchronoが入っていないのに対し、android-ndk-r10d\sources\cxx-stl\gnu-libstdc++\4.9\includeには入っていました。

Evan WallaceさんのWebGL Waterのソースを読んでみた

https://github.com/evanw/webgl-water
このレポジトリをローカルに取ってきてじっくり読んでみました。

波紋の作り方

浮動小数点数テクスチャをグリッドとして使っています。RGBAそれぞれを別の意味で使います。Rは水面の高さ、Gは水面の上下方向の加速度、BAは法線を格納するのに使います。

各グリッドのシミュレーションは以下の２つのルールで行います。

• 上下左右の隣接４グリッドの高さの平均が自分の高さと異なる場合、周囲に高さを合わせるように加速度を調節します。
• 各グリッドは自身の加速度によってのみ上下します。

グリッドは当然四角形ですが、上のルールだけで放射状に広がる波紋が出来るのが不思議です。

水面の法線の格納方法

シミュレーションが終わったらレンダリング前に各グリッドの法線を求め、上と同じテクスチャのBに法線のX、Aに法線のZを格納します。Yが格納されていませんが、法線は長さが常に１なので、ピタゴラスの定理と同じ原理でXとZからYを推測できます。

この方法の欠点は符号を復元できないことで、ここにXやZではなくYを省略する理由があります。WebGL WaterではY軸が上方向を向いており、常に正の方向になります。対してXとZは符号も保存する必要があります。

コースティック

水面が一切波立っていない場合と、水面が波立っている場合に分けて太陽光を水面で屈折させ、底または壁との衝突点を求めます。これを水面のグリッド全体で行い、波立っていない場合に比べて隣接グリッドの衝突点と自分の衝突点の距離が変化するかを見ます。広がった場合は光の密度が減り、狭まった場合は光の密度が増えると判断します。

密度の計算ですが、dFdx関数とdFdy関数を使うのがユニークです。つまり、各グリッドの波立っている場合と波立っていない場合の衝突点の計算を頂点シェーダで行い、それぞれvaryingでフラグメントシェーダに渡します。隣接グリッドの情報を直接読みに行くのではなくvaryingの変化量を見るだけなので追加のテクスチャフェッチが発生せず、高速に動作しそうです。

WebGLの拡張機能

浮動小数点数のテクスチャを使うため、OES_texture_float 拡張を使っています。

また、dFdx関数とdFdy関数を使うため、OES_standard_derivatives 拡張を使っています。

まとめ

簡潔で無駄の無いコードで、こんなきれいなエフェクトが作れるのはすごいですね。

Android StudioのGUIを使わずにビルド→インストール→起動

以下のようなバッチファイルをgradlew.batと同じ位置に作っておくことで、Android Studioを起動せずともコマンドライン又はエクスプローラからビルド、インストール、起動ができるようになります。NDKを使用している場合のビルドまで問題なく出来ました。

	call gradlew build
	pause

view raw build.bat hosted with ❤ by GitHub

adb install -r app\build\outputs\apk\app-debug.apk

view raw install.bat hosted with ❤ by GitHub

adb shell am start -a android.intent.action.MAIN -n com.pinotnoir.adamas/common.pinotnoir.glactivity.PinotGLActivity

view raw run.bat hosted with ❤ by GitHub

※ パッケージ名は、com.pinotnoir.adamasを、アクティビティ名はcommon.pinotnoir.glactivity.PinotGLActivityを置き換えてください。

ところで、"ADB server didn't ACK" というエラーに悩まされていたのですが、原因はNsight Tegra Visual Studio Editionでした。これが内部でADBをつかっているため衝突するようです。Visual Stuidio起動中に上のバッチファイルが使えない場合、Visual Studioを終了すると使えるようになりました。



Nsight Tegra Visual Studio Editionを一時停止することはできないようです。Visual StudioとAndroid Studioを同時に使いつつ、Nsight Tegraも使いたい場合、面倒なことになりそうです。Nsight Tegraをアンインストールすると衝突は起こらなくなりました。

GitHubのDirectXTKをgit submoduleとして組み込む

MicrosoftのGitHubアカウントでDirectXTKが公開されています。gitのsubmoduleとして組み込めるので格段に管理しやすくなりそうです。早速組み込んでみました。

組み込み方

git bashからDirectXTKを組み込みたいプロジェクトのディレクトリに移動し、以下のように入力すればDirectXTKフォルダ以下にDirectXTKのプロジェクトファイルが生成され、DirectXTKを参照するコミットを生成できます。

$ git submodule init
$ git submodule add https://github.com/Microsoft/DirectXTK.git DirectXTK
$ git commit -m "DirectXTK added as a submodule"

submoduleの何が良いのか

自分のレポジトリに外部のgitレポジトリの参照を加えることで、（半自動的に）一緒にチェックアウトできるようになります。自分のレポジトリを肥大化せずに外部モジュールを取り込めるわけです。また、参照にはバージョンも含まれているのでバージョンを取り違えてビルドに失敗することもありません。何より外部モジュールの組み込み方をgitが標準化したという側面が大きいです。

当然ながら、取り込みたいモジュールがgitレポジトリとして公開されているのが前提条件になるのですが、MicrosoftもGitHubでプロジェクトを公開してくれるようになりました。ありがたいですね。

submoduleは以下が詳しいです。

→ Git のさまざまなツール - サブモジュール

レポジトリについて

→ https://github.com/yorung/dx11x

D3DXやDirectX SDKを使わないモダンなDirectX11で.xファイルを読み込んで表示するプログラムです。スキニングも含めてアニメーションもひととおり対応しています。

OpenGL ES 2.0のvec4配列でUBOもどきを作る際の注意点

OpenGL ES 3.0ではUBOやVAOのような現状のハードウェアで効率的に動作するAPIが使えるようになります。しかし、開発者はモダンなAPIへの対応作業を迫られる一方、ES 2.0もサポートし続けなければいけません。https://developer.android.com/about/dashboards/index.html にもあるように未だに65%のデバイスはOpenGL ES 2.0であり、この状況は当分続きそうです。

「じゃあES2.0だけでいいや」では時代遅れになるので、ES2.0でもモダンなフリをしながら両バージョンでコードを共有する方法を模索してみます。

複数のuniform変数を配列化してひとつに

http://on-demand.gputechconf.com/gtc/2013/presentations/S3032-Advanced-Scenegraph-Rendering-Pipeline.pdf の24ページ目でuniform block(UBO)を使えない場合に、複数のuniformを配列にまとめて使う方法が提案されています。これは効率的であるのみならず、C側では構造体で転送するデータを管理できるので、UBOを使ったES 3.0のコードとのアーキテクチャの差を吸収できそうです。

https://devtalk.nvidia.com/default/topic/777618/scenix/announcing-nvpro-pipeline-a-research-rendering-pipeline/ この掲示板に動画もありますね。

mat4かvec4かfloatか

複数のuniformをまとめる際、どのような型の配列として渡すか決めなければなりません。行列だけのバッファならmat4の配列、色やベクトルだけならvec4配列にします。

mat4とvec4の混合のバッファを作りたい場合もあるかもしれません。そういうときはvec4の配列とするとよさそうです。mat4配列でもよいのですがバッファサイズがfloat16個単位になってしまうので柔軟性に欠けるからです。次のようにしてGLSL側でvec4を４つまとめてmat4を復元します。

	uniform vec4 uniformBuffer[9];
	void main() {
	mat4 matV = mat4(uniformBuffer[0], uniformBuffer[1], uniformBuffer[2], uniformBuffer[3]);
	mat4 matP = mat4(uniformBuffer[4], uniformBuffer[5], uniformBuffer[6], uniformBuffer[7]);
	float etc1 = uniformBuffer[8].x;
	float etc2 = uniformBuffer[8].y;
	float etc3 = uniformBuffer[8].z;
	}

view raw make_mat4_from_vec4.glsl hosted with ❤ by GitHub

	struct UniformBuffer
	{
	Mat matP, matV;
	float etc1, etc2, etc3, padding;
	};
	static UniformBuffer buf;
	void Write()
	{
	glUniform4fv(glGetUniformLocation(shaderId, "uniformBuffer"), sizeof(buf) / (sizeof(GLfloat) * 4), (GLfloat*)&buf);
	}

view raw write_uniform_into_vec4s.cpp hosted with ❤ by GitHub

ならば、vec4配列よりfloat配列のほうが柔軟そうですが、float４つを１単位とする癖をつけたほうが良いかもしれません。以下のポストはDirectX11のもので、NVIDIAによるものなので他のGPU全てに当てはまるかはわかりませんが、float４つ単位にしなかった場合の速度低下の可能性を示唆しています。

https://developer.nvidia.com/content/understanding-structured-buffer-performance

UBOとuniform vec4配列の違い

上のように、ES3.0のUBOのようなものをES 2.0で実現してみましたが、同一ではありません。UBOはシェーダから独立したバッファで、複数シェーダで共有可能です。uniformはシェーダの一部であってC側から書き換え可能な変数です。あるuniform vec4配列を複数のシェーダ間で共有したい場合、シェーダを切り替える度にglUniform4fvでバッファを転送してあげなければなりません。

OpenGL ES特有のprecisionの問題

ES特有のつまづきそうなポイントです。uniformはシェーダ間で共有できませんが、同じprogramに属するvertex shaderとfragment shaderに限って同じ名前のuniform変数を宣言すると共有されます。しかし、precisionが違うと共有できません（glLinkProgramでエラーになります）。vertex shaderではhighp、fragment shaderではmediump、のような使い方をすることが多いと思うので注意します。(fragment shaderでhighpがエラーになる機種もある）

언리얼엔진 4, 소스코드로부터 APK 생성 후기

무료화된 언리얼 엔진4로 APK를 만들어 보았습니다. GitHub로 제공되는데 PRIVATE리포지토리라서 언리얼 엔진 공식 사이트에서 회원등록해야 리포지토리에 접근이 됩니다.

소스코드 빌드와 에디터 실행

빌드 방법은 GitHub의 Readme.md에 다 나와 있어서, 지시대로 VisualStudio 2013로 빌드하고 실행하면 에디터가 뜹니다.

샘플 실행중의 모습.

안드로이드 바이너리 만들기

공식  https://docs.unrealengine.com/latest/KOR/Platforms/Android/GettingStarted/index.html

안드로이드 APK로 패키지합니다. ETC1텍스쳐를 지정하면 단말기를 가리지 않고 실행 가능할 겁니다...

missing UE4Game binary이란 에러가 떴습니다. 사전에 Visual Studio로 안드로이드 바이너리를 빌드하지 않으면 이런 에러가 뜹니다.
(참고: 옛날 버전 얘기입니다. 세상이 좋아져서 최근 버전은 에디터로부터 바이너리 생성까지 다 해줍니다! 따라서 아래 Visual Studio작업도 필요 없습니다.)

UE4.sln에서 Solution Configurations에 "Development", Solution Platforms에 "Android"를 지정해서 빌드하면 안드로이드 바이너리가 생성됩니다. 다시 에디터에서 패키지해 보니 APK가 생성되었습니다. 단말기에 APK를 전송해 주는 배치파일까지 만들어 주는 센스!



APK가 25MB, Obb파일이 1GB나 되네요. 깔아 보면 단말기에서는 100MB정도가 됩니다.

결론

언리얼엔진은 자료가 아주 잘 정리되어 있어서 APK까지 쉽게 만들 수가 있었습니다. 단점은 엔진 자체 크기 때문에 빌드 시간이 아주 깁니다. 소스코드 빌드 시간이 걸리는 것은 어쩔 수 없는데, 간단한 APK 생성이 30분 정도 소용이 됩니다. 언리얼 개발을 위해서는 하이엔드PC부터 맞추어야 될 것 같습니다.

그리고 어떤 단말기에서 실행이 안 되었습니다. Acer Iconia B1-730HD에서는 돌아갔는데, 팬택Vega Racer에서 안 돌아갔습니다. 하지만 TAPPY CHICKEN는 Vega Racer에서 실행되었으니 조정을 잘하면 될 수도 있겠네요...

OpenGL ESでのUniform Bufferのバインドの仕方(DX11比較付き)

Unifrom BufferはDirectX11のConstant Bufferとほぼ同じものです。OpenGL ES 3.1では使い方もよく似ていて、以下のようにGLSLの"binding"で指定するbinding pointがほぼHLSLの"register"と同じ概念です。

	// HLSL (DirectX11)
	cbuffer MyContantBuffer : register(b2)
	{
	float4x4 matW;
	}

view raw my_cb.fx hosted with ❤ by GitHub

	// GLSL
	layout (std140, binding = 2) uniform MyUBO {
	mat4 matW;
	};

view raw my_ubo.glsl hosted with ❤ by GitHub

C側からバッファを"register"に指定するID3D11DeviceContext::VSSetConstantBuffers に相当するのは、glBindBufferBaseです。

	// DirectX11
	#define POS 2
	pDeviceContext->VSSetConstantBuffers(POS, 1, &buffer);

view raw DX.cpp hosted with ❤ by GitHub

	// OpenGL
	#define POS 2
	glBindBufferBase(GL_UNIFORM_BUFFER, POS, ubo);

view raw GL.cpp hosted with ❤ by GitHub

OpenGL ES 3.1はここまでで動作します。

GLSLで"binding"が使えないOpenGL ES 3.0では以下のそれ相当の処理をC側から行う必要があります。これはOpenGL ES 3.1でも有効で、"binding"で指定するのと同じ結果になります。更には、既に"binding"指定があってもC側から上書きすることもできます。

	#define POS 2
	glUniformBlockBinding(program, glGetUniformBlockIndex(program, "MyUBO"), POS);

view raw layout.cpp hosted with ❤ by GitHub

Androidで動くモダンなインスタンシングを考える

このNVIDIAのスライドは基本的にPC対象です。しかし、昨今のゲーム業界はモバイル無しでは語れません。OpenGL ESで対応可能か機能を吟味してみます。

一発のDraｗCallでたくさんのオブジェクトを表示するには以下の様な機能が必要です。

1. インスタンシングのためのAPI
2. シェーダーからバッファにランダムアクセスする方法
3. シェーダーから複数のテクスチャにランダムアクセスする方法

サンプルプログラム程度の簡素なインスタンシングならglDrawElementsInstancedのようなAPIと、glVertexAttribDivisorでper instanceデータとして個別の座標等を渡せば済むので、2,3は無くてもいいかもしれません。しかし、マテリアルやボーンを変えてインスタンシングしたいなど、実用性を考えだすと2や3が必要となってきます。

まずは1のAPIですが、glMultiDrawElementsIndirectを使うと形の違うメッシュを一回のDrawCallで同時に描画できそうでした。しかし、残念ながらOpenGL ESでは使えなさそうです。glDrawElementsInstancedという、DirectX9時代からあった伝統的なインスタンシングで我慢します。

2と3は、マテリアルやボーンなどが異なるオブジェクトを一回のDrawCallで描くためには描画と描画の間にテクスチャの切り替えやバッファの更新を入れることができないため、描画対象の複数のオブジェクトが必要なデータを全部VRAMに上げておいて、シェーダーからランダムアクセスする必要があるということです。特にボーンが入っていて個別にアニメーションするとなると大きなバッファが必要です。

2. は嬉しいことに、OpenGL ES 3.1 ではSSBOという、ランダムアクセス可能なサイズの大きいバッファに対応しています。(資料https://www.khronos.org/assets/uploads/developers/library/2014-gdc/Khronos-OpenGL-ES-GDC-Mar14.pdf)しかし、Lollipopより前、KitKat以前のOpenGL ES 3.0の場合、uniformバッファを使う必要がありそうです。当然uniformの最大サイズに制限があるので、それより大きなバッファにランダムアクセスしたい場合はテクスチャにデータを格納してvertex texture fetchするなど更なる工夫が要求されます。

3.はbindless texture(ARB_bindless_texture)に対応していると理想的です。シェーダーからどのテクスチャにアクセスするかに関してほぼ制限がありません。しかし、OpenGL ESでは使えません。しかも、PCであっても比較的最近のものしか対応していないようです。

スライドではテクスチャをタイル化して大きなテクスチャを構成するARB_sparse_textureにも言及されていますが、同様にESでは使えません。

OpenGL ES 3.0 であればTexture Arraysが使えます。ただし、テクスチャのサイズやフォーマットを一致させる必要があるなど、アーティストに制限を課してしまうかもしれません。

古典的な手法ではTexture Atlasesや、あるいはインスタンシング対象はテクスチャを変えない、インスタンシングはしない、なども視野に入れて悩む必要がありそうです。

まとめ

PCなら以下のセットで異種混合インスタンシング

1. glMultiDrawElementsIndirect(ARB_shader_draw_parameters)
2. SSBO(ARB_shader_storage_buffer_object)
3. bindless texture(ARB_bindless_texture)

Lollipop(OpenGL ES 3.1)なら以下のセットでインスタンシング

1. glDrawElementsInstanced
2. SSBO(ARB_shader_storage_buffer_object)
3. Texture Arrays

OpenGL ES 3.0なら以下のセットでインスタンシング

1. glDrawElementsInstanced
2. uniform か vertex texture fetch
3. Texture Arrays

OpenGL ES 2.0はインスタンシングのAPIが無いのであきらめる。

OpenGLで異種混合インスタンシングを考える

レンダリングの高速化のためにはGPUとCPUの平行動作が重要で、一発のDrawCallで大量のモデルを描画するためにOpenGLの拡張が続けられています。2014年にはNVIDIA、AMD、INTEL各社がインスタンシングやbindless texture等の技術講義を行っていたようですね。

オーバーヘッドを減らすといえば、先日GDC2015で発表されたVulkanや、DX12の登場が待ち遠しいところですが、現状で使える最強のDrawCallはglMultiDrawElementsIndirectかと思われます。

伝統的なインスタンシングは同じモデルを大量に描画できるのに対し、glMultiDrawElementsIndirectは異なるモデルを一回のDrawCallに含められる点が頭一つ抜きん出ています。

GDC2014のスライド、
http://www.slideshare.net/CassEveritt/approaching-zero-driver-overhead
が網羅的に解説しています。

また、NVIDIAのスライド
http://www.slideshare.net/CassEveritt/beyond-porting?related=1
はモダンな描画方法の何がいいのかわかりやすく解説しています。NVIDIAのサンプルプログラムMultiDrawIndirectは異種混合インスタンシングを実現したサンプルです。

原理は簡単で、同一の頂点バッファに複数のモデルを含めておくだけです。頂点バッファのどの部分を描画に使うかは、DrawElementsIndirectCommand構造体の変数が指し示します。glMultiDrawElementsIndirectにはDrawElementsIndirectCommandを配列で渡せるので異種混合インスタンシングができます。ただし、同じ頂点フォーマット、同じシェーダー、同じレンダーステートどうしでないと一緒に描画できません。

また、残念なのはAndroidでは現状で最も機能豊富なAndroid Extension Packに対応していてもglMultiDrawElementsIndirectは使えなさそうなことです。

AndroidではglDrawElementsIndirectがES 3.1から、glDrawElementsInstancedがES 3.0から使えます。これらは基本的に一回のDrawCallで同じモデルを複数描画することができます。OpenGL ESでどうしても異種混合インスタンシングをしたいなら、ボーンを操作したりモーフィングしたりで形を変えながら別のモデルに見せることは出来るかもしれません。しかし、基本的にインスタンスごとにインデックスバッファを変えたり頂点数を変えたりできないです。

現状では異種混合インスタンシングはPC、あるいはフルスペックのOpenGLをサポートしたSHIELD tablet等でしか使えなさそうです。

Unreal Engine 4をソースからビルドしてAndroid用APKを作ってみる

Unreal Engine 4が無料化したので使ってみました。プログラマーなのでGitHubから取得します。無料化したとはいえGitHubではPRIVATEレポジトリなので、まずUnreal Engineの公式サイトで会員登録した上で自身のGitHubアカウントを紐付けます。すると、GitHubのUnreal Engineのレポジトリにアクセスできるようになります。

ソースコードのビルドからエディタ起動まで

必要な情報はGitHub上のReadme.mdにほとんど書いてあります。指示通りVisualStudio 2013でビルドするとエディタが起動しました。

サンプルプロジェクトを生成して実行している様子。ここまで何のエラーもありませんでした。えらく簡単です。

Android のバイナリの作り方

公式： https://docs.unrealengine.com/latest/JPN/Platforms/Android/GettingStarted/index.html

さっそく、AndroidのAPKを作ってみます。どの端末でも動くようにとりあえずテクスチャはETC1にしました。

missing UE4Game binary というエラーが出ました。アンドロイド用のバイナリをVisual Studioでビルドしていなかったのが原因です。
（追記：昔のバージョンの話です。最近はエディタからの操作だけでアンドロイド用のバイナリがコンパイル＆ビルドされます。よって、以下のVisual Studioからバイナリを作る手順も必要ありません）

UE4.slnで、Solution Configurationsを"Development"、Solution Platformsを"Android"にしてビルドします。改めてエディタからパッケージしてみると、APKの生成に成功しました。インストール用のバッチファイルを実行すればAndroid端末にインストールできます。



APKが25MB、obbファイルが1GB…何かの間違いではと思いたくなるサイズですが、実際にインストールすると100MB程になります。

まとめ

この少ない手順でソースコードからAPKまで作れるのは驚異です。ドキュメント類も充実していて迷うことがありません。難点もあります。ソースコードのビルドに時間がかかるのは当然かもしれませんが、APKの生成に30分程掛かりました。本格的に開発するとなるとSSD付のハイエンドPCが欲しいところです。

また、動く端末と動かない端末があります。Acer Iconia B1-730HDでは実行できたのですが、 Adreno 220搭載の Pantech Vega Racerでは動きませんでした。端末が古すぎるせいでしょうか。ただ、TAPPY CHICKENはVega Racerでも動いたので調整次第なのかと思います。

また、Unrealで作ったゲームは実行ファイルも大きく、端末でゲームが起動するまでに時間が掛かりました。ある程度規模の大きいゲーム向けであって、カジュアルゲームにはオーバースペックということかもしれません。

Visual StudioとAndroid StudioでOpenGLを使ったマルチプラットフォーム開発

実際に構築してみました。ここにコミットしています。
ソースを共用しながら、AndroidとWindowsの両方で動かせるようにしてみました。C++を主に使うのでNDKも入れておきます。

Android StudioでassetsフォルダやC++のソースを階層の浅い場所に移動

Androidのassetsフォルダにテクスチャやシェーダーを配置します。ただ、eclipse時代と違ってAndroid Studioはデフォルトで app/src/main/assetsとすごく深い場所にあります。これでは不便なので、build.gradle に以下のように書いて使いやすい場所を指定します。（同時にC++のソースも浅い場所に移動しています）

	android {
	sourceSets {
	main.jni.srcDirs = ['../../cpp']
	main.assets.srcDirs = ['../../assets']
	}
	}

view raw build.gradle hosted with ❤ by GitHub

main.assets.srcDirsはassetsを置く場所、main.jni.srcDirsはC++のファイルを置く場所です。'../../assets'のようにAndroid Studioのプロジェクトファイルより上位のフォルダも指定できることがわかりました。

Visual Studioからも同じソースやファイルを使うので、この任意のフォルダ位置を指定する機能は重宝します。

assetsフォルダをC++から使う

AndroidのassetsはC++から直接アクセスできないので、Javaを経由します。以下のようなヘルパークラスを作っておき、C++から使います。

	public class Helper {
	private static Context context;
	public static void setContext(Context c) { context = c; }
	public static byte[] loadIntoBytes(String fileName) {
	AssetManager assetManager = context.getAssets();
	try {
	InputStream is = assetManager.open(fileName);
	byte buf[] = new byte[is.available()];
	is.read(buf);
	return buf;
	} catch (IOException e) {
	}
	return null;
	}

view raw Helper.java hosted with ❤ by GitHub

	const char* boundJavaClass = "common/pinotnoir/Helper";
	void *LoadFile(const char *fileName, int* size)
	{
	jclass myview = jniEnv->FindClass(boundJavaClass);
	jmethodID method = jniEnv->GetStaticMethodID(myview, "loadIntoBytes", "(Ljava/lang/String;)[B");
	if (method == 0) {
	return nullptr;
	}
	jobject arrayAsJObject = jniEnv->CallStaticObjectMethod(myview, method, jniEnv->NewStringUTF(fileName));
	jbyteArray array = (jbyteArray)arrayAsJObject;
	jbyte* byteArray = jniEnv->GetByteArrayElements(array, NULL);
	jsize arrayLen = jniEnv->GetArrayLength(array);
	void* ptr = calloc(arrayLen + 1, 1);
	memcpy(ptr, byteArray, arrayLen);
	if (size) {
	*size = arrayLen;
	}
	jniEnv->ReleaseByteArrayElements(array, byteArray, 0);
	return ptr;
	}

view raw helper_android.cpp hosted with ❤ by GitHub

Javaでは指定のファイル名でassetsフォルダから読みだしてバイト列にしてC++側に返します。C++側でJavaからバイト列をもらい、改めてcallocでメモリを割り当て直してコピーしています。callocでサイズを+1しているのは、テキストファイルの終端に'\0'を入れたいためです。

テクスチャをJava経由でC++から生成

Android機はGPUによって対応している圧縮テクスチャフォーマットが違うので面倒です。この対応は後で考える事とし、とりあえず手始めにjpgやpngなどをまず使えるようにしておきます。
AndroidではJavaから直接テクスチャを生成すると簡単です。assetsフォルダからBitmapFactory.decodeStreamでBitmapを生成し、更にBitmapからGLUtils.texImage2Dでテクスチャを生成します。JavaからC++に渡すのはGLuint型(Javaではint型)の生成済みのテクスチャを表すtexture nameだけなのでシンプルに実装できます。

	class Helper {
	...
	public static int loadTexture(String s){
	Bitmap img;
	try {
	img = BitmapFactory.decodeStream(context.getAssets().open(s));
	} catch (IOException e) {
	return -1;
	}
	int tex[] = new int[1];
	GLES20.glGenTextures(1, tex, 0);
	GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, tex[0]);
	GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, img, 0);
	GLES20.glGenerateMipmap(GLES20.GL_TEXTURE_2D);
	GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR_MIPMAP_LINEAR);
	GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
	GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
	GLES20.glTexParameteri(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
	GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
	img.recycle();
	return tex[0];
	}

view raw Helper.java hosted with ❤ by GitHub

	static GLuint LoadTextureViaOS(const char* name)
	{
	jclass myview = jniEnv->FindClass(boundJavaClass);
	jmethodID method = method = jniEnv->GetStaticMethodID(myview, "loadTexture", "(Ljava/lang/String;)I");
	if (method == 0) {
	return 0;
	}
	return jniEnv->CallStaticIntMethod(myview, method, jniEnv->NewStringUTF(name));
	}

view raw tex_map.cpp hosted with ❤ by GitHub

Windows版の対応

それぞれAndroid版と同名のローダを作ります。

LoadFileはassetsフォルダのファイルをfopenでファイルを読み込むだけです。
LoadTextureViaOSではGDI+を使うことで、アルファチャンネル付きの32bitのrawデータが得られます。ここからテクスチャを生成しています。

	namespace Gdiplus {
	using std::min;
	using std::max;
	}
	#include <gdiplus.h>
	#pragma comment(lib, "gdiplus.lib")
	static GLuint LoadTextureViaOS(const char* name)
	{
	Gdiplus::GdiplusStartupInput gdiplusStartupInput;
	ULONG_PTR gdiplusToken;
	Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, nullptr);
	WCHAR wc[MAX_PATH];
	MultiByteToWideChar(CP_ACP, 0, name, -1, wc, dimof(wc));
	Gdiplus::Bitmap* image = new Gdiplus::Bitmap(wc);
	int w = (int)image->GetWidth();
	int h = (int)image->GetHeight();
	Gdiplus::Rect rc(0, 0, w, h);
	Gdiplus::BitmapData* bitmapData = new Gdiplus::BitmapData;
	image->LockBits(&rc, Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, bitmapData);
	std::vector<uint32_t> col;
	col.resize(w * h);
	for (int y = 0; y < h; y++) {
	memcpy(&col[y * w], (char*)bitmapData->Scan0 + bitmapData->Stride * y, w * 4);
	for (int x = 0; x < w; x++) {
	uint32_t& c = col[y * w + x];
	c = (c & 0xff00ff00) | ((c & 0xff) << 16) | ((c & 0xff0000) >> 16);
	}
	}
	image->UnlockBits(bitmapData);
	delete bitmapData;
	delete image;
	Gdiplus::GdiplusShutdown(gdiplusToken);
	GLuint texture;
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, &col[0]);
	glGenerateMipmap(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, 0);
	return texture;
	}

view raw tex_man.cpp hosted with ❤ by GitHub

GDI+とOpenGLではRGBAの並びが違うのでビットシフトで置き換えています。
OpenGLは以前作ったWGLGrabberを使って関数ポインタを取得しています。

ネイティブクラスの設計

基本的に出来る限りC++で処理すると決めたので、onTouchEventを使ったタッチ等のイベントは全部JavaからC++に渡します。また、GLSurfaceViewを使うので、onDrawFrameからC++のレンダラーを呼び出すことになります。

注意すべきはJavaのスレッドが２つあることです。onTouchEventはUIスレッド、onDrawFrameはレンダースレッドです。

今回は簡単にするため、タッチの座標だけ保存しておいてonDrawFrameの中からタッチイベントもC++に渡します。こうすることでC++は常にレンダースレッドで実行されることが保証されます。

将来的にはマルチスレッドの同期取りはC++側に移動したほうが最適化しやすいかもしれません。

まとめ

OpenGLを使った開発はOpenGL関連のコードが大多数を占めるので、このようにプラットフォーム依存する場所を開発の始めに括っておくと以後のマルチプラットフォーム化が楽になります。

DIY: Binding Lua5.3 with C++11

Let's bind C++ stuff to Lua5.3! :)

THE MEAT AND POTATOES

It might be enough to simple scripting for several projects.

	int MesBox(lua_State *L)
	{
	const char* str = lua_tostring(L, 1);
	MessageBoxA(nullptr, str, "LuaTest", MB_OK);
	return 0;
	}
	void Bind()
	{
	lua_register(L, "MesBox", MesBox);
	}

view raw mes_box.cpp hosted with ❤ by GitHub

MesBox("A message from Lua")

view raw mes_box.lua hosted with ❤ by GitHub

BRUTEFORCE WAY

Our main weapon is C++, so the above code doesn't satisfies me. So, let's bind C++ classes and create instances from Lua.

	class MyClass
	{
	public:
	int value;
	};
	static const char* myClassName = "MyClass";
	static int MyClassSetValue(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -2, myClassName);
	(*pp)->value = (int)lua_tointeger(L, -1);
	return 0;
	}
	static int MyClassGetValue(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -1, myClassName);
	lua_pushinteger(L, (*pp)->value);
	return 1;
	}
	static int MyClassGC(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -1, myClassName);
	delete *pp;
	return 0;
	}
	static int MyClassNew(lua_State *L)
	{
	MyClass** pp = (MyClass**)lua_newuserdata(L, sizeof(MyClass*));
	*pp = new MyClass;
	(*pp)->value = 0;
	luaL_getmetatable(L, myClassName);
	lua_setmetatable(L, -2);
	return 1;
	}
	void BindMyClass()
	{
	int r = luaL_newmetatable(L, myClassName);
	assert(r);
	lua_pushstring(L, "__index");
	lua_pushvalue(L, 1);
	lua_settable(L, -3);
	lua_pushstring(L, "__gc");
	lua_pushcfunction(L, MyClassGC);
	lua_settable(L, -3);
	lua_pushstring(L, "SetValue");
	lua_pushcfunction(L, MyClassSetValue);
	lua_settable(L, -3);
	lua_pushstring(L, "GetValue");
	lua_pushcfunction(L, MyClassGetValue);
	lua_settable(L, -3);
	lua_pop(L, 1);
	lua_register(L, "MyClass", MyClassNew);
	}

view raw my_class.cpp hosted with ❤ by GitHub

	local obj = MyClass()
	obj:SetValue(1234)
	print("My value is", obj:GetValue())

view raw my_class.lua hosted with ❤ by GitHub

My value is 1234

view raw output hosted with ❤ by GitHub

It works fantastic. Then MyClass is able to be generated with scripting, and the garbage collector calls our destructor and delete it.
However, it might be unpleasant chore to make additional method and classes. The bind code is too long and messy!

HACKING

Let's make stuff fun. The most brilliant thing for us is we are living in future. Now, C++11 allow us what we couldn't do before.

Below code is all to bind MyClass:

	#include <new>
	extern lua_State *L;
	class MyClass
	{
	public:
	MyClass()
	{
	value = 0;
	puts("MyClass::MyClass called");
	}
	~MyClass()
	{
	puts("MyClass::~MyClass called");
	}
	int value;
	};
	static const char* myClassName = "MyClass";
	#define GET_MYCLASS \
	MyClass* p = (MyClass*)luaL_checkudata(L, 1, myClassName); \
	if (!p) { return 0; }
	void BindMyClass()
	{
	static struct luaL_Reg methods[] =
	{
	{ "__gc", [](lua_State* L) { GET_MYCLASS p->~MyClass(); return 0; } },
	{ "SetValue", [](lua_State* L) { GET_MYCLASS p->value = (int)lua_tointeger(L, -1); return 0; } },
	{ "GetValue", [](lua_State* L) { GET_MYCLASS lua_pushinteger(L, p->value); return 1; } },
	{ nullptr, nullptr },
	};
	BindClass(L, myClassName, methods, [](lua_State* L) { new (lua_newuserdata(L, sizeof(MyClass))) MyClass; return 1; });
	}

view raw my_class_bind_final.cpp hosted with ❤ by GitHub

Most simple binds are able to be written with lambda. So, for compile it C++11 must be enabled. To prevent crashes by scripting bug, define a GET_MYCLASS macro to ensure the first element of the Lua stack is our MyClass. Note that MyClass instances are constructed with placement new. In this case, the destructor must be called directly instead of calling delete operator.

BindClass defined like below:

	static int CreateCppClassInstance(lua_State* L)
	{
	const char* className = lua_tostring(L, lua_upvalueindex(1));
	lua_CFunction actualInstanceCreator = lua_tocfunction(L, lua_upvalueindex(2));
	actualInstanceCreator(L);
	luaL_getmetatable(L, className);
	lua_setmetatable(L, -2);
	return 1;
	}
	static void CreateClassMetatable(lua_State* L, const char* className, luaL_Reg methods[])
	{
	luaL_newmetatable(L, className);
	lua_pushstring(L, "__index");
	lua_pushvalue(L, -2);
	lua_settable(L, -3);
	luaL_setfuncs(L, methods, 0);
	lua_pop(L, 1);
	}
	static void CreateClassInstanceCreator(lua_State* L, const char* className, lua_CFunction creator)
	{
	lua_pushstring(L, className);
	lua_pushcfunction(L, creator);
	lua_pushcclosure(L, CreateCppClassInstance, 2);
	lua_setglobal(L, className);
	}
	void BindClass(lua_State* L, const char* className, luaL_Reg methods[], lua_CFunction creator)
	{
	CreateClassMetatable(L, className, methods);
	CreateClassInstanceCreator(L, className, creator);
	}

view raw af_lua_helper.cpp hosted with ❤ by GitHub

As you can see, there is no MyClass dependencies. To avoid dependencies, I made a closer generator and put the class names and userdata creators into upvalue. Of course, BindClass can also be used for binding two or more extra classes.

CONCLUSION

Binding to Lua is not so complex and easy to learn. It's only combinations of small number of features such as stack and metatables. I saw programmers bothered increasing binding codes. I bet we can simplify them. Hope this helps to find your own solution.

自力Luaバインド 決定版

前回の続きです。クロージャでクラスのインスタンス生成をすっきり書けそうなのでやってみました。

	#include <new>
	extern lua_State *L;
	class MyClass
	{
	public:
	MyClass()
	{
	value = 0;
	puts("MyClass::MyClass called");
	}
	~MyClass()
	{
	puts("MyClass::~MyClass called");
	}
	int value;
	};
	static const char* myClassName = "MyClass";
	#define GET_MYCLASS \
	MyClass* p = (MyClass*)luaL_checkudata(L, 1, myClassName); \
	if (!p) { return 0; }
	void BindMyClass()
	{
	static struct luaL_Reg methods[] =
	{
	{ "__gc", [](lua_State* L) { GET_MYCLASS p->~MyClass(); return 0; } },
	{ "SetValue", [](lua_State* L) { GET_MYCLASS p->value = (int)lua_tointeger(L, -1); return 0; } },
	{ "GetValue", [](lua_State* L) { GET_MYCLASS lua_pushinteger(L, p->value); return 1; } },
	{ nullptr, nullptr },
	};
	BindClass(L, myClassName, methods, [](lua_State* L) { new (lua_newuserdata(L, sizeof(MyClass))) MyClass; return 1; });
	}

view raw my_class_bind_final.cpp hosted with ❤ by GitHub

ここまでシンプルにかければ、バインドの為の外部ライブラリの力を借りずとも十分やっていけそうです。BindClassという新たな関数が追加され、こちらに雑多なコードが移動しています。BindClassがuserdataを生成するだけの関数（ラムダで定義）を引数としている点がポイントです。ラムダでは前回同様userdata上にplacement newでインスタンスを初期化します。

	static int CreateCppClassInstance(lua_State* L)
	{
	const char* className = lua_tostring(L, lua_upvalueindex(1));
	lua_CFunction actualInstanceCreator = lua_tocfunction(L, lua_upvalueindex(2));
	actualInstanceCreator(L);
	luaL_getmetatable(L, className);
	lua_setmetatable(L, -2);
	return 1;
	}
	static void CreateClassMetatable(lua_State* L, const char* className, luaL_Reg methods[])
	{
	luaL_newmetatable(L, className);
	lua_pushstring(L, "__index");
	lua_pushvalue(L, -2);
	lua_settable(L, -3);
	luaL_setfuncs(L, methods, 0);
	lua_pop(L, 1);
	}
	static void CreateClassInstanceCreator(lua_State* L, const char* className, lua_CFunction creator)
	{
	lua_pushstring(L, className);
	lua_pushcfunction(L, creator);
	lua_pushcclosure(L, CreateCppClassInstance, 2);
	lua_setglobal(L, className);
	}
	void BindClass(lua_State* L, const char* className, luaL_Reg methods[], lua_CFunction creator)
	{
	CreateClassMetatable(L, className, methods);
	CreateClassInstanceCreator(L, className, creator);
	}

view raw af_lua_helper.cpp hosted with ❤ by GitHub

BindClassもこれだけで、特定のクラス名などが取り除かれ汎用化されています。CreateClassMetatableでメタテーブルを生成するのは定番のコードです。

C++にだけ慣れていると奇妙に見えるのはCreateCppClassInstanceです。これはLuaから呼べる関数型をしていますが単独では呼べません。upvalueという領域にクラス名とクラスのインスタンス生成を行う関数を結び付けてクロージャを生成しておくことで初めて関数として呼べるようになっています。そのクロージャを生成してクラス名と同名のグローバル関数を登録する部分がCreateClassInstanceCreatorです。

このようにしてクラスの種類数だけクロージャを生成することで、どんな種類のクラスインスタンスもCreateCppClassInstanceに生成させることが出来るようになります。

ところで、CreateCppClassInstanceのactualInstanceCreatorはlua_CFunction型として取り出して、直接CからactualInstanceCreatorを呼び出しています。これはBindClassの引数として受け取っているcreatorです。ということは、Luaが直接creatorを呼び出すことは無いのでlua_CFunction型を使う必要は無いということです。lightuserdataとして任意の型の関数にしても問題なさそうです。

LuaのC++バインドをラムダ式で書く

以前LuaからC++のクラスを使えるように自前バインドを書きました。しかし、非常に冗長でした。規模の大きいクラスになると恐ろしい長さになりそうです。そこで、C++11の恩恵に与りながら短く書き直してみました。

	#include <new>
	class MyClass
	{
	public:
	MyClass()
	{
	value = 0;
	puts("MyClass::MyClass called");
	}
	~MyClass()
	{
	puts("MyClass::~MyClass called");
	}
	int value;
	};
	static const char* myClassName = "MyClass";
	#define GET_MYCLASS \
	MyClass* p = (MyClass*)luaL_checkudata(L, 1, myClassName); \
	if (!p) { return 0; }
	static int MyClassNew(lua_State *L)
	{
	MyClass* p = new (lua_newuserdata(L, sizeof(MyClass))) MyClass;
	luaL_getmetatable(L, myClassName);
	lua_setmetatable(L, -2);
	return 1;
	}
	void BindMyClass()
	{
	int r = luaL_newmetatable(L, myClassName);
	assert(r);
	lua_pushstring(L, "__index");
	lua_pushvalue(L, 1);
	lua_settable(L, -3);
	static struct luaL_Reg methods[] =
	{
	{ "__gc", [](lua_State* L) { GET_MYCLASS p->~MyClass(); return 0; } },
	{ "SetValue", [](lua_State* L) { GET_MYCLASS p->value = (int)lua_tointeger(L, -1); return 0; } },
	{ "GetValue", [](lua_State* L) { GET_MYCLASS lua_pushinteger(L, p->value); return 1; } },
	{ nullptr, nullptr },
	};
	luaL_setfuncs(L, methods, 0);
	lua_pop(L, 1);
	lua_register(L, "MyClass", MyClassNew);
	}

view raw my_class_lambda.cpp hosted with ❤ by GitHub

まず、luaL_setfuncsで複数関数を一気に登録します。その際luaL_Regの配列を渡すのですが、関数部をラムダ式で書きます。MyClassのポインタはGET_MYCLASSというマクロで取得し、更に万一型が合わないなどで取得に失敗してもクラッシュしないようになっています。

また、placement newでMyClassのメモリ確保をluaに任せるようにします。これによってダブルポインタを使う無駄を省いた上にコードもすっきりしました。deleteのかわりにp->~MyClassを明示的に呼ぶ必要があります。placement newを使うためには #include <new>が必要です。

単独のサンプルとしてはこのくらいが最短かと思いますが、複数のクラスをバインドするなら上のコードの一部を共通化できるのでもう少し短くなりそうです。例えばメタテーブルを生成して__indexに自身を指定するあたりはサブルーチン化します。

MyClassNewはマクロ化すれば複数クラスで使いまわせそうです。本当はテンプレート関数化したいところですが、メタテーブルに渡す文字列をテンプレート引数にするにはややトリックが必要です。現状のC++では文字列定数をテンプレート引数に出来ないためです。

Luaでシェーダ言語のベクトルのswizzlingのようなことをしてみる

３ＤをやっているとLuaからC++のベクトルや行列にアクセスしたいことがあります。今回の目標はLuaからC++のベクトルを作って、更にシェーダ言語のswizzlingみたいなことをしてみます。例えばこんな感じに書けるようになります。

	local v = Vec4()
	v = Vec4(1, 2, 3, 4)
	v.wzyx = Vec4(1, 2, 3, 4)
	v = Vec4(1.111, 2.2222, 3.333, 4.444).wzyx
	v.w = 0

view raw vector_swizzling.lua hosted with ❤ by GitHub

これをやるためにはメタテーブルの"__index"と"__newindex"をそれぞれC関数として、実行時に解釈します。以下全ソースです。

	#include <algorithm>
	#include <string.h>
	#include "af_lua_helpers.h"
	#include "af_math.h"
	extern lua_State *L;
	static const char* myClassName = "Vec4";
	static float& vec4IndexByChar(Vec4& v, char c)
	{
	switch (c) {
	case 'x': return v.x;
	case 'y': return v.y;
	case 'z': return v.z;
	case 'w': return v.w;
	}
	static float dummyForSafe;
	return dummyForSafe;
	}
	static int Vec4GetLength(lua_State *L)
	{
	Vec4* self = (Vec4*)luaL_checkudata(L, -1, myClassName);
	float l = length(*self);
	lua_pushnumber(L, l);
	return 1;
	}
	static int Vec4ToString(lua_State *L)
	{
	char buf[64];
	Vec4* self = (Vec4*)luaL_checkudata(L, -1, myClassName);
	sprintf_s(buf, sizeof(buf), "(%f, %f, %f, %f)", self->x, self->y, self->z, self->w);
	lua_pushstring(L, buf);
	return 1;
	}
	static int Vec4NewIndex(lua_State *L)
	{
	DumpStack();
	Vec4* self = (Vec4*)luaL_checkudata(L, -3, myClassName);
	const char* key = lua_tostring(L, -2);
	if (!self || !key) {
	return 0; // error
	}
	int srcType = lua_type(L, -1);
	Vec4 src;
	Vec4* srcPtr;
	switch (srcType) {
	default:
	return 0; // error
	case LUA_TNUMBER:
	src.x = src.y = src.z = src.w = (float)lua_tonumber(L, -1);
	break;
	case LUA_TUSERDATA:
	if (!(srcPtr = (Vec4*)luaL_checkudata(L, -1, myClassName))) {
	return 0; // error
	}
	src = *srcPtr;
	break;
	}
	char key4[4] = {'\0', '\0', '\0', '\0'};
	memcpy(key4, key, std::min((size_t)4, strlen(key)));
	vec4IndexByChar(*self, key4[0]) = src.x;
	vec4IndexByChar(*self, key4[1]) = src.y;
	vec4IndexByChar(*self, key4[2]) = src.z;
	vec4IndexByChar(*self, key4[3]) = src.w;
	return 1;
	}
	static int Vec4Index(lua_State *L)
	{
	const char* key = lua_tostring(L, -1);
	if (!strcmp(key, "GetLength")) {
	lua_pushcfunction(L, Vec4GetLength);
	return 1;
	}
	Vec4* src = (Vec4*)luaL_checkudata(L, -2, myClassName);
	if (!key || !src) {
	return 0; // error
	}
	int keyLen = strlen(key);
	Vec4* ret = (Vec4*)lua_newuserdata(L, sizeof(Vec4));
	luaL_getmetatable(L, myClassName);
	lua_setmetatable(L, -2);
	ret->x = keyLen < 1 ? 0 : vec4IndexByChar(*src, key[0]);
	ret->y = keyLen < 2 ? 0 : vec4IndexByChar(*src, key[1]);
	ret->z = keyLen < 3 ? 0 : vec4IndexByChar(*src, key[2]);
	ret->w = keyLen < 4 ? 0 : vec4IndexByChar(*src, key[3]);
	return 1;
	}
	static int Vec4New(lua_State *L)
	{
	int top = lua_gettop(L);
	Vec4 v;
	v.x = top < 4 ? 0 : (float)lua_tonumber(L, -4);
	v.y = top < 3 ? 0 : (float)lua_tonumber(L, -3);
	v.z = top < 2 ? 0 : (float)lua_tonumber(L, -2);
	v.w = top < 1 ? 0 : (float)lua_tonumber(L, -1);
	Vec4* p = (Vec4*)lua_newuserdata(L, sizeof(Vec4));
	*p = v;
	luaL_getmetatable(L, myClassName);
	lua_setmetatable(L, -2);
	return 1;
	}
	void BindVec4()
	{
	int r = luaL_newmetatable(L, myClassName);
	assert(r);
	lua_pushstring(L, "__tostring");
	lua_pushcfunction(L, Vec4ToString);
	lua_settable(L, -3);
	lua_pushstring(L, "__index");
	lua_pushcfunction(L, Vec4Index);
	lua_settable(L, -3);
	#if 0
	// wrong! it's never used; __index doesn't refer itself
	lua_pushstring(L, "GetLength");
	lua_pushcfunction(L, Vec4GetLength);
	DumpStack();
	lua_settable(L, -3);
	DumpStack();
	#endif
	lua_pushstring(L, "__newindex");
	lua_pushcfunction(L, Vec4NewIndex);
	lua_settable(L, -3);
	lua_pop(L, 1);
	lua_register(L, "Vec4", Vec4New);
	}

view raw vector_swizzling.cpp hosted with ❤ by GitHub

swizzlingして読みだす時（右辺に来るとき）はVec4Index、swizzlingして書き込む時（左辺にくるとき）はVec4NewIndexが呼ばれます。

Vec4NewIndexで、代入する値がベクトルであってもスカラーであってもいいようにLUA_TNUMBERとLUA_TUSERDATAに分岐しています。

Luaからベクトルの長さを得るGetLengthというメソッドがあります。BindVec4関数内でバインドしようとしているのはだめな例です。なぜならBindVec4で作っているのはメタテーブルであって、__で始まるメタメソッドは定義出来ても任意のメソッドは定義できません。前回のMyClassはメタテーブルの__indexにメタテーブル自身を参照させていたのでメタテーブル内に任意のメソッドを定義することができましたが、今回は__indexをswizzlingのためのC関数であるVec4Indexにつかってしまっています。

ではどうするのかというと、Vec4Index関数の中で"GetLength"を参照しようとしたかを判定してVec4GetLength関数を返しています。これでLuaからGetLengthが使えます。

テストはこれでいいかもしれませんが、実際に使えるものにするにはもうひと工夫する必要がありそうです。

Lua stack dump (WRONG CASE)

	void _dumpStack(lua_State* L, const char* func, int line)
	{
	int top = lua_gettop(L);
	printf("(%s,%d) top=%d\n", func, line, top);
	for (int i = 0; i < top; i++) {
	int positive = top - i;
	int negative = -(i + 1);
	int type = lua_type(L, positive);
	const char* typeName = lua_typename(L, type);
	const char* value = lua_tostring(L, positive); // danger!!! numbers on the Lua stack will be replaced with string
	printf("%d/%d: type=%s value=%s\n", positive, negative, typeName, value);
	}
	}

view raw wrong_lua_stack_dump.cpp hosted with ❤ by GitHub

This is very simple Lua stack dumper. It extracts all element values by using lua_tostring whatever the types is not a string. It looks work well, but the problem is that lua_tostring overwrites values in the stack by string version.

One of correct code is below. The programmer always needed to take a step to ensure their correct types when accessing the Lua stack.

	void _dumpStack(lua_State* L, const char* func, int line)
	{
	int top = lua_gettop(L);
	printf("(%s,%d) top=%d\n", func, line, top);
	for (int i = 0; i < top; i++) {
	int positive = top - i;
	int negative = -(i + 1);
	int type = lua_type(L, positive);
	int typeN = lua_type(L, negative);
	assert(type == typeN);
	const char* typeName = lua_typename(L, type);
	printf("%d/%d: type=%s", positive, negative, typeName);
	switch (type) {
	case LUA_TNUMBER:
	printf(" value=%f", lua_tonumber(L, positive));
	break;
	case LUA_TSTRING:
	printf(" value=%s", lua_tostring(L, positive));
	break;
	case LUA_TFUNCTION:
	if (lua_iscfunction(L, positive)) {
	printf(" C:%p", lua_tocfunction(L, positive));
	}
	break;
	}
	printf("\n");
	}
	}

view raw correct_lua_stack_dump.cpp hosted with ❤ by GitHub

DIY: Bind OpenGL(WGL) APIs using std::regex

Windows SDK doesn't provides direct way to access modern OpenGL APIs. So, as you know developers suffer to choose the method to acquire huge amount of address of WGL APIs. (or just decide using GLEW)

The popular DIY option is parsing the Khronos Group's extension header files with script languages and generate C++ glue code. But, I didn't. A good news is std::regex is now available on Visual Studio 2013, So I felt it's the simplest option to do.

	struct GLFunc
	{
	GLFunc(){}
	GLFunc(const GLFunc& r) {
	*this = r;
	}
	const GLFunc& operator=(const GLFunc& r) {
	name = r.name;
	decl = r.decl;
	caster = r.caster;
	return *this;
	}
	std::string name;
	std::string decl;
	std::string caster;
	};
	std::vector<GLFunc> glFuncs;
	void ParseHeader(const char* healderFileName, const char* regExp, const char* conventions)
	{
	char* h = (char*)LoadFile(healderFileName);
	std::string str = h;
	std::regex pattern(regExp);
	auto funcBegin = std::sregex_iterator(str.begin(), str.end(), pattern);
	auto End = std::sregex_iterator();
	int dist = std::distance(funcBegin, End);
	printf("%d functions found in %s\n", dist, healderFileName);
	int i = 0;
	for (auto it = funcBegin; it != End; it++) {
	std::smatch m = *it;
	if (m.size() < 4) {
	continue;
	}
	GLFunc func;
	func.name = m[2].str();
	func.decl = m[1].str() + "(" + conventions + "*" + m[2].str() + ")" + m[3].str();
	func.caster = m[1].str() + "(" + conventions + "*)" + m[3].str();
	glFuncs.push_back(func);
	printf("\r%d/%d", ++i, dist);
	}
	printf("\n");
	free(h);
	}
	int _tmain(int argc, _TCHAR* argv[])
	{
	ParseHeader("glheaders/glcorearb.h", "^GLAPI\\s+([\\w\\s\\*]+)APIENTRY\\s+(gl\\w+)\\s*(\\(.*\\))", "APIENTRY");
	ParseHeader("glheaders/wglext.h", "^(\\w+(?:\\s+\\w+)*\\s+)WINAPI\\s+(wgl\\w+)\\s*(\\(.*\\))", "WINAPI");
	return 0;
	}

view raw wgl_grabber.cpp hosted with ❤ by GitHub

Tools are always getting better and better! Isn't it?:)

std::sregex_iterator looks wired from the perspective of STL programmers, but it is the way for multiple match of OpenGL API declaration in the header files.(std::regex_match is only for single match, it wasn't for me) and std::smatch contains divided parts of a declaration, such as name of API, return type and parameters.

My project files are available on GitHub.

Lua5.3を自力バインド

LuaとC++を自力でつないでみます。

以前はtolua++を使っていましたが、グルーコードを毎回生成するのが意外と不便でした。ヘッダの日付が変わってしまったために全体ビルドがかかってしまったりします。nmakeやバッチファイルを導入してみたり、自動生成したファイルをバージョン管理に含めるべきか悩んだりしました。結局外部定義ファイルよりはcppに直接バインド内容を書けてしまうほうが悩まないかもしれません。

例えば、WindowsのMessageBoxをLuaから使えるようにするコードです。あっけないほど簡単です。わざわざ外部のライブラリを導入する必要もないです。プロジェクトの性質によってはこれで十分用足りるでしょう。

	int MesBox(lua_State *L)
	{
	const char* str = lua_tostring(L, 1);
	MessageBoxA(nullptr, str, "LuaTest", MB_OK);
	return 0;
	}
	void Bind()
	{
	lua_register(L, "MesBox", MesBox);
	}

view raw mes_box.cpp hosted with ❤ by GitHub

MesBox("A message from Lua")

view raw mes_box.lua hosted with ❤ by GitHub

ここからが本題です。C++を使うからにはC++っぽいことをしたいわけです。目指す仕様は、

・C++のクラスをバインドしてLuaからインスタンスを作る
・グルーコードでnewからdeleteまで勝手にやってくれる
・ガーベージコレクションの時点でdeleteさせたい

これを実現したコードが以下です。

	class MyClass
	{
	public:
	int value;
	};
	static const char* myClassName = "MyClass";
	static int MyClassSetValue(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -2, myClassName);
	(*pp)->value = (int)lua_tointeger(L, -1);
	return 0;
	}
	static int MyClassGetValue(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -1, myClassName);
	lua_pushinteger(L, (*pp)->value);
	return 1;
	}
	static int MyClassGC(lua_State *L)
	{
	MyClass** pp = (MyClass**)luaL_checkudata(L, -1, myClassName);
	delete *pp;
	return 0;
	}
	static int MyClassNew(lua_State *L)
	{
	MyClass** pp = (MyClass**)lua_newuserdata(L, sizeof(MyClass*));
	*pp = new MyClass;
	(*pp)->value = 0;
	luaL_getmetatable(L, myClassName);
	lua_setmetatable(L, -2);
	return 1;
	}
	void BindMyClass()
	{
	int r = luaL_newmetatable(L, myClassName);
	assert(r);
	lua_pushstring(L, "__index");
	lua_pushvalue(L, 1);
	lua_settable(L, -3);
	lua_pushstring(L, "__gc");
	lua_pushcfunction(L, MyClassGC);
	lua_settable(L, -3);
	lua_pushstring(L, "SetValue");
	lua_pushcfunction(L, MyClassSetValue);
	lua_settable(L, -3);
	lua_pushstring(L, "GetValue");
	lua_pushcfunction(L, MyClassGetValue);
	lua_settable(L, -3);
	lua_pop(L, 1);
	lua_register(L, "MyClass", MyClassNew);
	}

view raw my_class.cpp hosted with ❤ by GitHub

	local obj = MyClass()
	obj:SetValue(1234)
	print("My value is", obj:GetValue())

view raw my_class.lua hosted with ❤ by GitHub

My value is 1234

view raw output hosted with ❤ by GitHub

C++のBindMyClass関数でLua内にMyClassというクラスをメタテーブルで定義します。MyClassはSetValueとGetValueという２つのメソッドを持ち、__gcでガーベージコレクションの直前に呼ぶ関数があることをLuaに教えます。__indexはやや特殊ですが、MyClassのインスタンスがメソッドを探しに行くテーブルがメタテーブル自身であることを示します。これによってメタテーブル内にメソッドを定義できます。

最後のlua_registerで"MyClass"という名前のLua関数を呼ぶとC++側のMyClassNew関数がインスタンスを生成して返します。クラス名と同じ名前の関数として登録していますが関数名は何でも構いません。MyClassNewではLuaのユーザーデータを生成してC++側で生成したMyClassのポインタを格納し、先ほど作っておいたMyClassのメタテーブルを設定します。

MyClassSetValueとMyClassGetValueはLua側からC++側の変数に値を格納したり取り出したりする所です。せっかくなのでLua5.3の新機能である整数形式を試してみます。lua_Integerはデフォルトで64bitになりました。よって、int型に代入する場合キャストしないとwarningが出ます。

一見複雑ですが、アセンブリを読むような難解さはあれど覚えることはそう多くはないです。一度自力でバインドする方法を試しておくと、たとえ他のオープンソースのバインダーを使う場合でもより理解しやすくなるはずです。

GitHubはここです。

Google ANGLEでWindows上でOpenGL ESを使う簡単な方法

AndroidでOpenGL ESを使ったアプリを開発する際にAPKを生成してデバイスに転送しながらデバッグするのは非効率です。そこで、Windows上でもOpenGL ESを実行できるようにしてゲームエンジン部を共通化しておくと便利です。

直接WindowsのOpenGLを動かせるようにしてもよいのですが、下位でDirectXを呼ぶANGLEで組むとIntel GPAやNVIDIA Nsightでデバッグできるメリットも得られます。

ところで、最近 git clone https://chromium.googlesource.com/angle/angle からcloneするだけではVisual Studioのslnファイルが得られなくなっているようです。以下のページで説明されているようにdepot_toolsという独自の環境を構築する必要があります。

https://code.google.com/p/angleproject/wiki/DevSetup

しかし、とりあえず最新でなくてもいいので以前のように手間をかけずに手軽に実行したい場合はslnを含む最後のブランチである"2214"をチェックアウトするといいです。 git bashより以下のように入力します。

1. git clone https://chromium.googlesource.com/angle/angle
2. git branch 2214 origin/chromium/2214
3. git checkout 2214

これで2214 ブランチをチェックアウトできました。
angle\projects\build\all.sln が生成されているのでビルドします。
   
なぜかessl_to_glsl, essl_to_hlslという二つのプロジェクトからエラーが出ますが、気にしないことにします。

 



自分のプロジェクトの必要に応じてヘッダとライブラリを設定します。こうして作ったプロジェクトをGitHubにアップしておきました。

std::regexを使い、自力でOpenGL（WGL）バインド

WindowsでOpenGLを使う為にはwglGetProcAddress関数でAPIの関数ポインタを収集しなければなりません。文字列処理に長けたスクリプト言語でパーサを作って https://www.opengl.org/registry/ のヘッダからCのソースを生成するのが一般的かと思いますが、Visual Studio 2013でregexがstd::regexに移動していたのでC++だけでやってみることにします。

	struct GLFunc
	{
	GLFunc(){}
	GLFunc(const GLFunc& r) {
	*this = r;
	}
	const GLFunc& operator=(const GLFunc& r) {
	name = r.name;
	decl = r.decl;
	caster = r.caster;
	return *this;
	}
	std::string name;
	std::string decl;
	std::string caster;
	};
	std::vector<GLFunc> glFuncs;
	void ParseHeader(const char* healderFileName, const char* regExp, const char* conventions)
	{
	char* h = (char*)LoadFile(healderFileName);
	std::string str = h;
	std::regex pattern(regExp);
	auto funcBegin = std::sregex_iterator(str.begin(), str.end(), pattern);
	auto End = std::sregex_iterator();
	int dist = std::distance(funcBegin, End);
	printf("%d functions found in %s\n", dist, healderFileName);
	int i = 0;
	for (auto it = funcBegin; it != End; it++) {
	std::smatch m = *it;
	if (m.size() < 4) {
	continue;
	}
	GLFunc func;
	func.name = m[2].str();
	func.decl = m[1].str() + "(" + conventions + "*" + m[2].str() + ")" + m[3].str();
	func.caster = m[1].str() + "(" + conventions + "*)" + m[3].str();
	glFuncs.push_back(func);
	printf("\r%d/%d", ++i, dist);
	}
	printf("\n");
	free(h);
	}
	int _tmain(int argc, _TCHAR* argv[])
	{
	ParseHeader("glheaders/glcorearb.h", "^GLAPI\\s+([\\w\\s\\*]+)APIENTRY\\s+(gl\\w+)\\s*(\\(.*\\))", "APIENTRY");
	ParseHeader("glheaders/wglext.h", "^(\\w+(?:\\s+\\w+)*\\s+)WINAPI\\s+(wgl\\w+)\\s*(\\(.*\\))", "WINAPI");
	return 0;
	}

view raw wgl_grabber.cpp hosted with ❤ by GitHub

追加ライブラリ無しで正規表現が書けました。

STLに慣れているとstd::sregex_iteratorが奇妙に見えますが、これで複数のOpenGL関数定義を巡回させます。std::regex_matchでも正規表現を実行できますが、こちらは最初の一回しかマッチさせられません。マッチ結果はstd::smatchを使って戻り値、関数名、引数リストを取り出します。

GitHubはここです。