dowasureDBjsの利用例

dowasureDBjsの詳しい説明はこちら ※ソース（jsとphp）は説明ページのgithubへのリンクから落とせます テストを兼ねて、取引先とファイルをやりとりするためのアップローダを作ってみました。アップローダといっても誰でも書き込める公開タイプのではなく、大きなファイルを送るために「宅ふぁいる便」的な目的で使うものです。ファイルをアップロードする部分はphpを書かざるをえなかったのですが、dowasureDBjsを使うことで、ユーザー認証と、フォルダのアクセス制御（他の取引先のフォルダが見えないように制限）の部分は比較的簡単に作ることができました。

アップローダのソース

http://i-libro.net/wpmu/blog/archives/1094 かなり時間が空いてしまいましたが、BulletとDXライブラリに関する解説の続きです。今回はBulletの計算結果に合わせて、DXライブラリで3Dモデルを表示する方法を解説します。

DXBullet_3DTest_src02.zip（要Visual C++ 2010 Express）

DXBullet_3DTest_bin02.zip（実行ファイル）

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

©CRYPTON FUTURE MEDIA, INC.
解説中で使用しているモデルは前回に続きenamel toy box（ハッチさん運営）で公開されている「PMDねんどろ風初音ミクv1.1」

pmdファイルのダウンロードや組み合わせ方については、過去記事も参考にしてください。

動かしてみよう

最初にサンプルプログラムを実行して、結果を確認してください。前回のサンプルを改造したもので、落ちてくるブロックの下にモデルが表示されるようにしています。ブロックがモデルに当たると、回転したり床から落っこちたりします。

座標系の変換

前回記事ではすっかり忘れていたのですが、DXライブラリはDirect3Dと同じ左手座標系、Bulletは右手座標系なので表示する前に変換してやらなければいけません。そのための関数を数カ所に加えています（座標系については初回記事を参照）。

「_dxdebugdraw.h」の中で定義しているbtVGet関数は、btVector3からVECTOR型に変換するためのものですが、このときにZ軸の正負を反転させます。

●_dexdebugdraw.h

//DXライブラリ用のBox2Dのデバッグドロー

#include <DxLib.h>

#include <LinearMath/btIDebugDraw.h>

class DxDebugDraw : public btIDebugDraw{
private:
	int m_debugMode;
	//座標変換
	inline VECTOR btVGet(const btVector3 &inv){return VGet(inv.getX(), inv.getY(), -inv.getZ());}
public:

●main.h

上記の関数はDxDebugDrawクラスの中でしか使えないので、同じ働きをする関数を「main.h」にも加えます。

//座標変換
inline VECTOR btVGet(const btVector3 &inv){return VGet(inv.getX(), inv.getY(), -inv.getZ());}
inline VECTOR btRotVGet(const btVector3 &inv){return VGet(-inv.getX(), -inv.getY(), inv.getZ());}

btVGet関数は、位置を左手座標系に変換するために使います。btRotVGet関数は、回転角度を左手座標系に変換するために使います。

これ以降、プログラムで座標を指定するときはbulletに合わせて右手座標系を使うことにします。そうしておけば、

ゲームの処理→bulletの処理→左手座標系に変換→DXライブラリで表示

という一方通行で済むので、考え方が簡単になるわけです。

モデルに対応するボディを物理空間に追加する

まず、モデルに対応する直方体のボディを追加します。実はここが一番調べるのに時間がかかりました。直方体のボディはbtBoxShapeクラスを使って簡単に作れるのですが、これは常に直方体の中心が原点となります。ところがサンプルで使用するモデルは、足下が原点となっているため、そのままだとボディの位置とモデルの位置がずれてしまうのです。

APIドキュメントによれば、自由な形のボディを追加したい場合はbtConvexHullShapeクラスを使うらしいのですが、たかだか原点をずらした直方体を作る程度で頂点を細かく設定していくのは面倒です。色々と調べた結果、btCompoundShapeクラスを使うことに思い至りました。btCompoundShapeクラスは複数のシェイプを組み合わせてシェイプを作ります。その際に位置や角度を行列で指定できるのです。

●main.cpp

//ステージ初期化
void InitStage(){
	//古いアニメーション情報を削除
	EraseAnimInfo(&g_stage.heroanim);

	//ゲームデータ全体のゼロ初期化
	ZeroMemory(&g_stage, sizeof(g_stage));
	//全ボディ・ジョイント削除
	DeleteAllBody();
	SetBasicDemo();

	//主人公位置の初期化
	g_stage.heropos = VGet( 318.0f, 210.0f, -353.0f );
	//アニメーション情報を初期化
	InitAnimInfo(&g_stage.heroanim, g_images.hero, HERO_STAND);
	btCompoundShape *heroshape = new btCompoundShape();
	btBoxShape *box = new btBoxShape(btVector3(btScalar(2.5),btScalar(5.),btScalar(2.5)));
	btTransform shift;
	shift.setIdentity();
	shift.setOrigin(btVector3(0,5,0));
	heroshape->addChildShape(shift, box);
	m_collisionShapes.push_back(heroshape);
	m_collisionShapes.push_back(box);
	//初期位置と角度設定
	btTransform transform, center;
	transform.setIdentity();
	transform.setOrigin(btVector3(g_stage.heropos.x, g_stage.heropos.y, g_stage.heropos.z));
	transform.setRotation(btQuaternion(0, 3.14f, 0, 0));//向き
	btScalar mass(1.);	//質量0なら静的ボディ
	btVector3 localInertia(0,0,0);
	heroshape->calculateLocalInertia(mass,localInertia);
	btDefaultMotionState* myMotionState = new btDefaultMotionState(transform);
	btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,heroshape,localInertia);
	g_stage.herobody = new btRigidBody(rbInfo);
	g_world->addRigidBody(g_stage.herobody);

	//ゲーム開始時刻の記録
	g_stage.gamestarttime = g_lasttime;
}

まず、new演算子を使ってbtCompoundShapeのインスタンスを作成して、ポインタshapeに代入します（16行）。次に（5, 10, 5）というサイズのbtBoxShapeのインスタンスを作成して、ポインタboxに代入します（17行）。

btTransform型の変数shiftを定義し、setIdentitiy関数で初期化してから、setOrigin関数で（0,5,0）という移動行列を設定します（18～20行）。これでボックスは上に5ずらされることになります。

btCompoundShapeクラスのaddChildShape関数を使い、shapeにboxを追加します（21行）。

※サンプルファイルではm_collisionShapesにboxを入れ忘れているので、69行目の後辺りに「m_collisionShapes.push_back(box);」を加えておいてください。そうしなくても動作しますが、deleteAllBody関数がboxを削除してくれないのでメモリリークが起きます。

ここから先は前回記事の「ボディを追加する」で説明したものとほぼ同じ処理です。

異なっている点はボディの初期位置を設定するtransformに対して、setRotation関数で回転角度を設定している点です。座標系などの都合で、初期設定のままだとモデルが後ろ向きになってしまうため、Y軸で180度回転させています（28行）。

できあがったボディはg_stage.herobodyに記憶させておきます（34行）。

ボディに合わせてモデルを表示する

DrawGameMain関数の中で、ボディの位置と角度を調べ、それに合わせてモデルを描画します。こちらはそれほど複雑な処理ではありません。

●main.cpp

void DrawGameMain(){
	//DrawBox(0,0,640,480, 0xFFDDDD, TRUE);
	//キー取得
	int key = GetJoypadInputState(DX_INPUT_KEY_PAD1);

	int herostate = HERO_STAND;
	if((key & PAD_INPUT_LEFT) || (key & PAD_INPUT_RIGHT)) {
		herostate = HERO_RUN;
	}
	if(key & PAD_INPUT_B){
		herostate = HERO_JUMP;
	}
	if(IsBKeyTrigger(key)==true) GoGameClear();
	//アニメーション設定
	StepAnimTime(&g_stage.heroanim, herostate);

	//移動と表示
	btTransform herotrans;	//bulletから情報を取得
	g_stage.herobody->getMotionState()->getWorldTransform(herotrans);
	//　位置取得
	g_stage.heropos = btVGet(herotrans.getOrigin());
	MV1SetPosition(g_stage.heroanim.model, g_stage.heropos);
	//　角度取得
	btMatrix3x3 rot = herotrans.getBasis();
	btVector3 euler;
	rot.getEulerZYX(euler[2], euler[1], euler[0]);
	MV1SetRotationXYZ(g_stage.heroanim.model, btRotVGet(euler));
	MV1DrawModel(g_stage.heroanim.model) ;

	//カメラの設定
	SetCameraPositionAndTarget_UpVecY(btVGet(btVector3(320.0f, 240.0f, -420.0f)),
		 btVGet(btVector3(320.0f, 210.0f, -310.0f) ) );
	//ちょっとした視点変更
	if(key & PAD_INPUT_C){
		SetCameraPositionAndTarget_UpVecY(btVGet(btVector3(320.0f, 240.0f, -450.0f)),
			g_stage.heropos );
	}
	SetCameraNearFar(10, 1000);
	SetupCamera_Perspective( PHI_F / 5 );
	//SetupCamera_Ortho(150);
	//テキスト表示
	DrawStringToHandle(60, 0, "Xキーでタイトルへ、Cキーで視点変更",
		0xFFFF00, g_middlefont);
}

btTransform型の変数herotransを定義します（18行）。btRidigBodyクラスのgetMotionState関数でbtMotionStateクラスのインスタンスを取得し、さらにそのgetWorldTransform関数を呼び出して変形行列を取得します（19行）。APIリファレンスを見る限り、btMotionStateクラスは変形行列を記憶しておく程度の役割しかないようです。

位置はbtTransformクラスのgetOrigin関数で取得できます。ここでbtVGet関数を利用して左手座標系に変換します（21行）。後はDXライブラリの関数でモデルに位置を設定します。

角度はまずgetBasis関数で3×3行列を取り出し、getEulerZYX関数でX、Y、Z軸それぞれの回転角度を取り出します（24～26行）。ちなみにEuler（オイラー）はオイラー角のことです。後はそれをbtRotVGet関数で左手座標系に変換し、DXライブラリの関数で設定します（27行）。

DXライブラリでのモデル表示やアニメーションについては過去記事を参照してください（過去記事1、過去記事2）。

DXBullet_3DTest_src01.zip（要Visual C++ 2010 Express）

DXBullet_3DTest_bin01.zip（実行ファイル）

Bulletの使い方も基本的な部分はBox2Dと同じです。すなわち、

1. 最初にワールドを作る
2. ワールドにボディ（rigid body＝剛体）を追加する
3. 定期的にstepSimulation関数を呼び出す

という流れは同じなのです。ただし、Bulletはいくつかのコンポーネントに分かれていて、必要な部分だけを組み合わせて利用できるような設計になっています。その分、Box2Dより複雑です。また、結構重いです。3Dのゲームが満足に動くスペックのパソコンがあったほうがいいでしょう。

ここでは前に作ったBox2D用のサンプルプログラムを元に、Bulletに置き換える形で改造しました。

デバッグドロー用のコードを書く

まずは共通点が多いデバッグドローの部分から移植することにします。デバッグドローというのは、テスト用にボディを簡易描画する機能です。物理エンジンを使うときは物理エンジンが算出した座標、角度などに合わせて、DirectX、OpenGL、DXライブラリなどの描画APIを使って3Dモデルを描いていくのですが、その処理に間違いがあると、物理エンジンの結果と画面に表示されたものが合わなくなってしまいます。こういうときに物理エンジンのデバッグドローを使えば、物理エンジンがどういう結果を出しているのかを直接見ることができるわけです。

まず、Bulletのサンプルからデバッグドローを担当しているクラスを探し、そのソースコードをコピーします。中身はOpenGL用になっているので、それをDXライブラリ用に書き換えていきます。

ヘッダファイルは、ほぼコピペしてクラス名を変えたぐらいですが、11行目でbtVGetという独自の関数を宣言しています。これはBulletが使うbtVector3構造体を受け取り、DXライブラリ用のVECTOR構造体を返す関数です。

●_dxdebugdraw.h

//DXライブラリ用のBox2Dのデバッグドロー

#include <DxLib.h>

#include <LinearMath/btIDebugDraw.h>

class DxDebugDraw : public btIDebugDraw{
private:
	int m_debugMode;
	//座標変換
	inline VECTOR btVGet(const btVector3 &inv){return VGet(inv.getX(), inv.getY(), inv.getZ());}
public:
	DxDebugDraw();
	virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& fromColor, const btVector3& toColor);
	virtual void drawLine(const btVector3& from,const btVector3& to,const btVector3& color);
	virtual void drawSphere (const btVector3& p, btScalar radius, const btVector3& color);
	virtual void drawBox (const btVector3& boxMin, const btVector3& boxMax, const btVector3& color, btScalar alpha);
	virtual void drawTriangle(const btVector3& a,const btVector3& b,const btVector3& c,const btVector3& color,btScalar alpha);
	virtual void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color);
	virtual void reportErrorWarning(const char* warningString);
	virtual void draw3dText(const btVector3& location,const char* textString);
	virtual void setDebugMode(int debugMode);
	virtual int	getDebugMode() const { return m_debugMode;}
};

cppファイルの中身はDXライブラリの3D図形描画関数を使って、だいたい同じ結果になるようにしています。

●_dxdebugdraw.cpp

//DXライブラリ用のBox2Dのデバッグドロー

#include "_dxdebugdraw.h"

//コンストラクタ
DxDebugDraw::DxDebugDraw()
:m_debugMode(0)
{

}

void DxDebugDraw::drawLine(const btVector3& from,const btVector3& to,const btVector3& fromColor, const btVector3& toColor)
{
	DrawLine3D(btVGet(from), btVGet(to),
		GetColor( int(fromColor.getX()*255), int(fromColor.getY()*255), int(fromColor.getZ()*255) )
		);
}

void DxDebugDraw::drawLine(const btVector3& from,const btVector3& to,const btVector3& color)
{
	drawLine(from,to,color,color);
}

void DxDebugDraw::drawSphere (const btVector3& p, btScalar radius, const btVector3& color)
{
	DrawSphere3D(btVGet(p), radius, 10,
		GetColor( int(color.getX()*255), int(color.getY()*255), int(color.getZ()*255) )
		, 0xFFFFFF, TRUE);
}
……後略……

ワールドを作る

いくつかのグローバル変数を定義していきます。main.cppにはbtDynamicsWorld型のポインタg_worldを定義します。Bulletにはワールドのためのクラスが数種類があり、btDynamicsWorld型その元となる抽象クラスです。そのサブクラスのbtDiscreteDynamicsWorldクラスやbtSoftRigidDynamicsWorldクラスのインスタンスを作成して、ポインタに代入します。ワールド用のクラスは4種類ぐらいあり、どう違うのかは今のところ調べ切れていません。単純な剛体での物理演算ではbtDiscreteDynamicsWorldクラスを使うようです。

その後のbtClockは時間計測用のクラスですが結局使っていません。

●main.cpp

#include "main.h"

//グローバル変数
GameState g_gamestate = GAME_TITLE;

//box2d関連
btDynamicsWorld*	g_world;
btClock m_clock;

_utils.cppでは、DxDebugDraw型変数のg_debugdrawを定義します。これは後でg_worldに設定してやります。

他に5つの変数やポインタを定義しています（10～14行目）。btAlignedObjectArrayはボディの形（シェイプ）を記憶するコレクションクラスです。他の4つの用途は調べ切れていませんが、World用クラスのインスタンスを作る際に必要なものです。どうやら独自の衝突判定処理を書きたいときに、これらのサブクラスを作るようです。

●_utils.cpp

//デバッグドロー
#ifdef  B2D_DEBUG_DRAW
DxDebugDraw g_debugdraw;
#endif
//フォント
int g_middlefont;			//中サイズフォントハンドル

//keep the collision shapes, for deletion/cleanup
btAlignedObjectArray<btCollisionShape*>	m_collisionShapes;
btBroadphaseInterface*	m_broadphase;
btCollisionDispatcher*	m_dispatcher;
btConstraintSolver*	m_solver;
btDefaultCollisionConfiguration* m_collisionConfiguration;

ワールドを作る処理はinitBullet関数にまとめました。この関数はWinMain関数でメインループを始める前に呼び出すようにしています。ソースコードを三手の通り、いくつかのクラスのインスタンスを作って各ポインタに代入していき、最後にsetGravity関数で重力を設定します。色々と謎な部分があるのですが、今回の例ではこのとおりにやっておけば問題ないようです。

●_utils.cpp

void initBullet(){
	//デフォルトの衝突処理を登録？
	///collision configuration contains default setup for memory, collision setup
	m_collisionConfiguration = new btDefaultCollisionConfiguration();
	//m_collisionConfiguration->setConvexConvexMultipointIterations();
	///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
	m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);

	//衝突判定を効率化するためのもの？
	m_broadphase = new btDbvtBroadphase();

	///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded)
	btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
	m_solver = sol;

	//ワールド作成
	g_world = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);

	//重力設定
	g_world->setGravity(btVector3(0,-10,0));

}

ボディを追加する

ボディを追加する処理はmain.cppのSetBasicDemo関数にまとめました。下記は「地面」の役割をするスタティックボディを追加している部分です。この後に上から落下するダイナミックボディを追加する処理が続きます。

●main.cpp

void SetBasicDemo(){
	//地形のシェイプを作成
	{
		///create a few basic rigid bodies
		btCollisionShape* groundShape =
			new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.)));
	//	btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),50);

		//衝突判定に登録
		m_collisionShapes.push_back(groundShape);

		//地形の位置を設定？
		btTransform groundTransform;
		groundTransform.setIdentity();
		groundTransform.setOrigin(btVector3( 320.0f, 160.0f, -350.0f));

		//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
		//質量と慣性の設定？
		btScalar mass(0.);	//質量0なら静的ボディ
		//rigidbody is dynamic if and only if mass is non zero, otherwise static
		bool isDynamic = (mass != 0.f);
		btVector3 localInertia(0,0,0);
		if (isDynamic){
			groundShape->calculateLocalInertia(mass,localInertia);
		}

		//シェイプから剛体を作成？
		//using motionstate is recommended, it provides interpolation capabilities, and only synchronizes 'active' objects
		btDefaultMotionState* myMotionState = new btDefaultMotionState(groundTransform);
		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,myMotionState,groundShape,localInertia);
		btRigidBody* body = new btRigidBody(rbInfo);

		//ワールドに配置
		//add the body to the dynamics world
		g_world->addRigidBody(body);
	}
……後略……

まず、btCollisionShapeクラスのインスタンスを作成します（5～6行）。btBoxShape（箱）の他にbtSphereShape（球）など色々な種類があります。以下のクラス構成図を参考にしてください。ここでは（50, 50, 50）と指定しているので、一辺の長さ100の立方体が作られます。

http://www.continuousphysics.com/Bullet/BulletFull/classbtCollisionShape.html

作成したシェイプはbtAlignedObjectArray型のm_collisionShapesにpush_back関数で登録します。これはおそらく衝突判定で使用されるはずです（10行）。

次に初期位置をbtTransform型変数に記憶します（13～15行）。

質量（mass）と慣性（localInertia）の値を設定します。massを0にすると動かないスタティックボディに、0より大きい値にするとダイナミックボディになります。ダイナミックボディにするときはcalculateLocalInertia関数で質量と慣性を設定します（19～25行）。

btTransform型変数を引数にして、btDefaultMotionState型のインスタンスを作成します。これはボディの位置と重心位置を設定するためのもののようです（29行）。

これまで作ってきたいくつかのインスタンスを引数にして、btRigidBodyConstrucionInfo型のインスタンスを作成し、それを引数にしてbtRigidBody型のインスタンスを作成します（30～31行）。

最後にaddRigidBody関数でワールドに追加します。

ボディの反発率や摩擦力、速度などはbtRigidBodyクラスのメンバ関数で設定します。

http://www.continuousphysics.com/Bullet/BulletFull/classbtRigidBody.html

シミュレーションを進める

後は定期的にstepSimulation関数を呼び出せば、Bulletが各ボディの位置を計算で求めてくれます。stepSimulation関数の第1引数に進めたい時間をミリ秒で指定しますが、この値が使われるのは第2引数が0のときです。第2引数が1以上だとデフォルト値の60分の1秒（もしくは第3引数に指定した値）で計算を進めます。Bulletは60fpsの動作に最適化されているらしいのですが、ここでは低スペックのパソコンでも動くよう0を指定して、現実の経過時間に合わせた動きにしています。

※追記：どうも第2引数に0を指定すると、挙動にムラが出過ぎる印象です。「stepSimulation(g_frametime, 1, 1.0f/30.0f);」として30fpsとするか、「stepSimulation(g_frametime);」として60fpsのまま使ったほうがいいような気がしてきました。

●main.cpp

//メインループ
void MyMain(){
	//ゲーム開始からの時間を計る
	g_stage.gametime = g_lasttime - g_stage.gamestarttime;
	//b2bの時間を進める
	g_world->stepSimulation(g_frametime, 0);
	//各画面の描画
	switch(g_gamestate){
	case GAME_TITLE:
		DrawGameTitle();
		break;
	case GAME_MAIN:
		DrawGameMain();
		break;
	case GAME_CLEAR:
		DrawGameClear();
		break;
	case GAME_OVER:
		DrawGameOver();
		break;
	}
}

デバッグドローで描画するには、メインループが始まる前にsetDebugDrawer関数でデバッグドロー用関数のインスタンスを設定し、setDebugMode関数で何を描画するかを設定します（12～13行）。そして、メインループの中でdebugDrawWorld関数を呼び出します。

●_utils.cpp

	//3Dエンジンバレット初期化
	initBullet();

	SetDrawScreen( DX_SCREEN_BACK );
	//ファイルの読み込み
	if( LoadFiles() == -1) {
		MessageBox(NULL, "ファイル読み込み失敗", "DXライブラリ", MB_OK);
		return -1;
	}
	//デバッグドロー用
#ifdef B2D_DEBUG_DRAW
	g_world->setDebugDrawer(&g_debugdraw);
	g_world->getDebugDrawer()->setDebugMode(btIDebugDraw::DBG_DrawWireframe);
#endif

	g_lasttime = GetNowCount() & INT_MAX;	//現在時刻の記録
	while(	ProcessMessage() == 0 && g_exitflag==FALSE )
	{
		//1ループにかかった時間を計測
		int curtime = GetNowCount() & INT_MAX;
		g_frametime = (float)(curtime - g_lasttime) / 1000.0f;
		g_lasttime = curtime;
		//フレーム間隔が異常に延びた場合は0.03秒とする
		if (g_frametime > 0.03f) g_frametime = 0.03f;

		ClsDrawScreen();
		MyMain();
		//デバッグドロー
#ifdef B2D_DEBUG_DRAW
		g_world->debugDrawWorld();
#endif
		ScreenFlip();
	}

すべてのボディを削除する

サンプルプログラムでは、Xキーを押すとタイトル画面に戻り、すべてのボディを削除します。この処理を見ると、すべてのボディを列挙する方法がわかります。

//全ボディの削除
void DeleteAllBody(){
	//cleanup in the reverse order of creation/initialization

	//remove the rigidbodies from the dynamics world and delete them
	int i;
	for (i=g_world->getNumCollisionObjects()-1; i>=0 ;i--)
	{
		btCollisionObject* obj = g_world->getCollisionObjectArray()[i];
		btRigidBody* body = btRigidBody::upcast(obj);
		if (body && body->getMotionState())
		{
			delete body->getMotionState();
		}
		g_world->removeCollisionObject( obj );
		delete obj;
	}

	//delete collision shapes
	for (int j=0;j<m_collisionShapes.size();j++)
	{
		btCollisionShape* shape = m_collisionShapes[j];
		delete shape;
	}
	m_collisionShapes.clear();
}

ボディを削除するには、getNumCollisionObjects関数で総数を調べて逆順のループをし、getCollisionObjectArray関数で1つずつ取り出して削除していきます（7～9行）。

削除するときはまずgetMotionState関数でbtMotionStateのインスタンスを削除し、その後removeCollistionObject関数でボディを削除しないといけないようです（11～16行）。

その後はシェイプをすべて削除します（20～25行）。

以上で説明は終わりです。ここからゲーム作りに持って行くには、最低でも

• btRigitBodyの扱い方
• 衝突判定の使い方
• 描画するべきボディを列挙する方法

などを調べなければいけないでしょう。

－ブロックが床に落下して飛び散る。

DXBullet_3DTest_src01.zip（要Visual C++ 2010 Express）

DXBullet_3DTest_bin01.zip（実行ファイル）

Bulletをダウンロードする

まずは公式サイトからBulletをダウンロードします。

http://bulletphysics.org/wordpress/

－左上に小さく表示されている「Bullet Download」をクリック

－一番上の「bullet-278.zip」をダウンロードして解凍する

解凍したファイルを適当な場所に保存します。適当といっても、VCディレクトリで参照するので後から移動しなくてもいいところにしてください。今回は「c:\temp」というフォルダに保存しました。

解凍したフォルダ内の「msvc」フォルダに、Visual C++ 2008用のソースコードが格納されているので、それを開きます。

－「msvc」を開く

「2008」「2008_amd_opencl」「2008_dx11_directcompute」の3種類があります。DXライブラリはDirectX9ベースなので、「2008」の中のソースコードを使うことにします。ちなみdx11用は筆者のノートパソコンでは重すぎて動かせませんでした。

－「2008」を開く

－slnファイルをダブルクリック

－「Visual C++ 2010」を選ぶ

－「完了」をクリックしてVC++2010用に変換

これをビルドすると、コンパイルとリンクは無事終わるはずですが、最後に「指定されたファイルが見つかりません」というエラーが表示されます。これはプロパティ設定で、実行ファイルを4階層上のフォルダに出力するようになっているためです。

－ビルドにはちょっと時間がかかる

－エラーが出て起動できない。

Bulletのフォルダに移動すると、「AppAllBulletDemos.exe」というファイルができているはずです。なぜ、ここに作るかというと、デモプログラムがこのフォルダの中にあるOpenGL用のdllファイルを使用するからです。ダブルクリックして実行すると、デモを起動することができます。

－AppAllBulletDemos.exeをダブルクリック

－右上の「Tests」でデモの種類を選ぶ

DXライブラリ用にビルドし直す

このプロジェクトが出力する「lib」ファイルを利用するのですが、その前にDXライブラリに合わせてビルドし直す必要があります。変更が必要なのは1点、「ランタイムライブラリ」を「マルチスレッドデバッグdll」から「マルチスレッドデバッグ」に変更することです。リリースビルド用のlibファイルを作りたい場合は、「マルチスレッド」を選びます。

－「Shift」キーを押しながらクリックして、全プロジェクトを選択し、右クリックして「プロパティ」を選択

－「構成プロパティ」→「C/C++」→「コード生成」を選択し、「ラインタイムライブラリ」から「マルチスレッドデバッグ（/MTd）」を選択

またビルドし直すと、「lib」フォルダ内の「Debug」フォルダの中に大量のlibファイルが作られます。

DXライブラリでBulletを使うためのプロジェクト設定

自分で作ったプログラムでBulletを使うには、それに合わせたプロジェクト設定をしなければいけません。「AppAllBulletDemos」プロジェクトのプロパティを参考にしながら設定していきます。

プロジェクトを作成したら、まずはVC++ディレクトリを設定して、Box2DではなくBulletのフォルダを参照させます。

－「構成プロパティ」→「VC++ディレクトリ」を選択

－Bulletのフォルダのsrcフォルダを指定

－先ほどビルドして作ったlibファイルがあるDebugフォルダを指定

「全般」設定はふだんDXライブラリを使うときと同じはずです。

「C/C++」→「コード生成」では、「拡張命令セットを有効にする」で「ストリーミングSIMD拡張機能」を選びます。

「リンカー」→「入力」で追加の依存ファイルの設定を行います。

追加するのは次の表のとおりです。「AppAllBulletDemos」プロジェクトの設定を参考にし、そこからOpenGL周りの設定を抜きました。間違えるとビルドできないので、ここからコピー＆ペーストしたほうがいいでしょう。

長くなったので、ここで一区切りとします。次の記事ではサンプルのソースコードの中身について説明していきます。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

引き続き前々回記事で公開したマリオブラザーズ風のゲームデモのグラフィックス処理について解説していきます。今回説明するのは表示範囲内にあるモデルを絞り込む方法です。範囲内の物体を高速に行うのは意外と面倒なのですが、ここではBox2DのQueryAABBという関数を使います。AABBは「Axis Aligned Bounding Box」の略で、「軸に沿った範囲を表す矩形」という意味になります。軸に沿わない――つまり回転もありうる矩形に比べると、高速に判定ができるわけです。

QueryAABB関数はb2Worldクラスのメンバ関数で、引数にはb2QueryCallback型のcallbackと、b2AABB型のaabbを取ります。callbackは範囲内にあるボディがあったときに呼び出してもらう関数を指定し、aabbには範囲を指定します。

void b2World::QueryAABB (b2QueryCallback *callback, const b2AABB &aabb ) const

まずはcallbackに渡す関数から用意します。まず、ヘッダファイルにb2QueryCallbackクラスを継承したクラスの定義を書きます。

//表示範囲の地形を判定するためのコールバック
class ViewAreaQueryCallback : public b2QueryCallback
{
public:
	bool ReportFixture(b2Fixture* fixture);
};

「継承」や「クラス」と聞くと難しく感じるかもしれませんが、今回の場合は上記のとおりに書いておけば問題ありません。ここではC++の文法についてはあまり細かくは説明しませんが、クラスの定義の書き方を見せておきましょう。

QueryAABB関数は「ReportFixture」という名前の関数を呼び出すよう設計されているので、それを名前も引数も間違えないように定義しなければいけません。b2QueryCallbackクラスの定義には「絶対にReportFixture関数を間違えないように書けよ！」という指令が書いてあるので、そのクラスを継承すると、もし間違いがあればコンパイラがエラーを出してくれるのです。

ReportFixture関数の定義は次のように書きます。中に書くことは後で説明するので、先にqueryAABB関数の使い方を説明しましょう。

bool ViewAreaQueryCallback::ReportFixture(b2Fixture* fixture){
……この後実行したい処理を書く……
}

範囲を指定してqueryAABB関数を呼び出す

queryAABB関数の呼び出しは、前回説明したRenderAll関数の中に書いています。

//レンダリング
void RenderAll(){
	……中略……
	//物理エンジンでのスクリーン座標を求める
	//DebugDraw時にDRAWSCALERATE倍にしていることに注意
	float phy_screen_x = (float)g_stage.screen_x / (WLDSC * DDRAWSCALERATE);
	float phy_screen_y = (float)g_stage.screen_y / (WLDSC * DDRAWSCALERATE);

	//表示範囲内にいる地形と敵を描画する
	//Box2DのQueryAABB関数を使って範囲内のボディを列挙させる
	clsDx();	//デバッグドロー用の処理なので意味はなし
	ViewAreaQueryCallback callback;
	b2AABB aabb;
	aabb.lowerBound.Set(phy_screen_x-1.0f, phy_screen_y-1.0f);
	aabb.upperBound.Set((float)(g_stage.screen_x+640) / (WLDSC * DDRAWSCALERATE)+1.0f,
		(float)(g_stage.screen_y+480) / (WLDSC * DDRAWSCALERATE)+1.0f );
	g_world.QueryAABB(&callback, aabb);
#ifdef B2D_DEBUG_DRAW
	//表示範囲内を表す四角形を描画する
	DrawBox(VIWX(aabb.lowerBound.x), VIWY(aabb.lowerBound.y),
		VIWX(aabb.upperBound.x), VIWY(aabb.upperBound.y), 0x888888, FALSE);
#endif
	……後略……

6～7行目は前回説明した「物理座標系での表示範囲の左上隅の座標値（phy_screen_x, phy_screen_y）」を求める計算です。

12行目でb2QueryCallbackクラスを継承したViewAreaQueryCallbackクラス型の変数を定義しています。

13行目でb2AABB型の変数aabbを定義し、そのb2Vec2型メンバ変数のlowerBoundとupperBoundに、表示範囲の左上隅と右下隅の座標を指定します。

後はQueryAABB関数を呼び出すだけです（17行目）。

ReportFixture関数内でモデルを描画する

範囲内にボディが入っている場合、その数だけReportFixture関数が呼び出されます。その中でモデルの描画を行っていきます。

描画するものの種類ごとに処理を分けなければいけないので、関数内の記述は長めですが基本的にはモデルの描画処理の繰り返しです。

main.cpp

//表示範囲内の地形ブロックを描画する
bool ViewAreaQueryCallback::ReportFixture(b2Fixture* fixture){
	b2Body *body = fixture->GetBody();
	if(body != NULL){
		Character *ch = (Character*)body->GetUserData();
		b2Vec2 epos = body->GetPosition();
		float eangle = body->GetAngle();
		b2Vec2 evec = body->GetLinearVelocity();

		//キャラ種別ごとの処理
		if(ch->type >= MAP_GROUND && ch->type <= MAP_PIRAMID){
			//printfDx("MAP BLOCK Found!\n");
			int curmodel = g_images.cube1;
			switch(ch->type){
			case MAP_FRAGILE:
				curmodel = g_images.cube3;
				break;
			case MAP_HATENA:
				curmodel = g_images.cube5;
				break;
			case MAP_PIPE1:
			case MAP_PIPE2:
			case MAP_PIPE3:
			case MAP_PIPE4:
				curmodel = g_images.cube2;
				break;
			case MAP_PIRAMID:
				curmodel = g_images.cube4;
				break;
			}
			DrawBlocks(curmodel, VIW3D(epos.x+0.3f, epos.y+0.54f, WORLDZPOS + 5.0f),
				ch->size / 36, eangle);
		} else if(ch->type == MAP_GOALFLAG) {
			//printfDx("GOAL Flag Found!\n");
			MV1SetPosition(g_images.goalflag, VIW3D(epos.x+0.3f, epos.y+0.54f, WORLDZPOS + 5.0f));
			MV1DrawModel(g_images.goalflag);
		} else if(ch->type == MAP_MONSTER_MASHROOM){
			//printfDx("Monster Found!\n");
			//キノコモンスターの描画処理
			int idx = ch->enemyidx;
			if(g_stage.monster[idx].used == false) return true;
			//モンスターのアニメーション進行
			if(evec.x < 0) StepAnimTime(&g_stage.enemyanim[idx], 1);
			else StepAnimTime(&g_stage.enemyanim[idx], 0);
			//変形と描画
			MV1SetPosition(g_stage.enemyanim[idx].model, VIW3D(epos.x, epos.y+0.54f) );
			MV1SetRotationXYZ(g_stage.enemyanim[idx].model, VGet(0.0f, -PHI_F/2, 0.0f));
			MV1DrawModel(g_stage.enemyanim[idx].model);
		}
	}
	//検索を継続する場合はtrue
	return true;
}

関数の引数として、ボディの形状を表すフィクスチャーが渡されます。そこから描画するモデルの情報を取り出すために、b2FixtureクラスのgetBody関数を使ってボディを取得し、ユーザー情報、位置、角度、速度を取り出します（3～8行）。速度は敵キャラクターの移動方向を調べるために使います。

ユーザー情報はmain.h内で定義しているCharacter構造体で、そのメンバ変数typeにキャラクターの種類を表す定数が記憶されているので、それを使って描画します。

地形に使うモデルは今回唯一自作したもので、36ピクセル÷50×10＝7.2に納まるようなサイズで作成しています。

マップデータ内ではボディの数を減らすために、ブロック複数個分をまとめて1つのボディとして扱っています。そこで、ブロックを並べて表示するDrawBlocks関数も定義しました。ブロックの数などを受け取ると、その数だけ並べて描画します。

main.cpp

void DrawBlocks(int model, VECTOR center, int num, float eangle){
	float startx = center.x - UNITSIZE_3D * ((float)num / 2.0f);
	for(int i=0; i<num; i++){
		MV1SetPosition(model, VGet(startx + UNITSIZE_3D * i, center.y, center.z));
		MV1SetRotationXYZ(model, VGet(-eangle, 0.0f, 0.0f));
		MV1DrawModel(model);
	}
}

マリオ風ゲームの解説はこれでおしまいです。

3Dグラフィックスについてはまだまだ解説していないことがたくさんありますが、ここまでの内容だけでも色々な2Dゲームを3D化することができるはずです。ぜひ挑戦してみてください。

いつになるかわかりませんが、機会を見て完全3Dのゲームプログラミングの解説もやりたいものだと考えております。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

引き続き前々回記事で公開したマリオブラザーズ風のゲームデモのグラフィックス処理について解説していきます。解説を書く中でソースコード中の問題をいくつか見つけて修正したので、新たにこちらのソースコードをダウンロードし直してください。

maori-bros3D_src2.zip（要Visual C++ 2010 Express）

横スクロールタイプのゲームでは、ステージ内のどこを画面に表示するのかを決めなければいけません。3Dグラフィックスの場合、どこが表示されるかを決めるのはカメラです。カメラがどこに配置され、どこを注視しているかによって、「何がどこに表示されるのか」が決定されます。つまり、スクロールの進行に合わせてカメラを動かさなければならないということです。

サンプルプログラムの2D部分では、左右は主人公が画面中央に来るようにスクロールし、上下は画面の端から200px以内に主人公が入ったときにスクロールすることにしています。そのために主人公の現在位置から、表示範囲の左上隅座標（screen_x, screen_y）を求める計算を行っています。

以下はその計算を行っているRenderAll関数の冒頭です。この関数はDrawGameMain関数やDrawGameOver関数から呼び出され、画面描画をまとめて行います。

main.h

void RenderAll(){
	//スクロール座標調整
	b2Vec2 pos = g_stage.hero.body->GetPosition();
	int hx = (int)(pos.x * WLDSC * DDRAWSCALERATE);
	int hy = (int)(pos.y * WLDSC * DDRAWSCALERATE);
	g_stage.screen_x = hx - 320;
	if(	hy - SCROLL_LIMIT < g_stage.screen_y ){
		g_stage.screen_y = hy - SCROLL_LIMIT;
	}
	if( 480 - SCROLL_LIMIT < hy - g_stage.screen_y ){
		g_stage.screen_y = hy + SCROLL_LIMIT - 480;
	}
	……続く……

まず、Box2Dでの主人公の座標を変数posに求め、前回説明した単位変換の計算（50を掛けてさらに1.5を掛ける）を行って、2D画面表示用の座標hx、hyを求めます。

左右は常に主人公が画面中央に来るようスクロールするので、hxから画面幅の半分の320を引いたものをscreen_xに記憶します。

上下スクロールでは、主人公と画面上下端の距離を調べ、それが定数SCROLL_LIMIT（200px）未満なら、SCROLL_LIMITの間隔を保つようにscreen_yを調整します。

カメラの座標を決める

screen_x、screen_yは表示範囲の左上端を表しています。ここからカメラの位置を求めます。カメラは表示範囲の中央を映すように配置する必要があるので、screen_x、screen_yの位置から2D座標で（320,240）だけ移動した位置にします。

以下はRenderAll関数内のカメラ位置の設定を行っている部分です。

main.cpp

	……前略……
	//物理エンジンでのスクリーン座標を求める
	//DebugDraw時にDRAWSCALERATE倍にしていることに注意
	float phy_screen_x = (float)g_stage.screen_x / (WLDSC * DDRAWSCALERATE);
	float phy_screen_y = (float)g_stage.screen_y / (WLDSC * DDRAWSCALERATE);

	……中略……

	//カメラ設定
	VECTOR campos = VIW3D(phy_screen_x, phy_screen_y, WORLDZPOS - 30.0f);
	campos.x += 320 / (WLDSC * DDRAWSCALERATE) * VIEW3DSCALE;
	campos.y -= 240 / (WLDSC * DDRAWSCALERATE) * VIEW3DSCALE;
	VECTOR atpos = VGet(campos.x, campos.y, WORLDZPOS);
	SetCameraPositionAndTargetAndUpVec(campos, atpos, VGet(0,1,0) );
	SetCameraNearFar(10, 1000);
	SetupCamera_Ortho(70);
}

まず、2D座標のscreen_x、screen_yをBox2Dの座標系のphy_screen_x、phy_screen_yに変換します（50*1.5で割る）。それを元にVIW3D関数で3Dの座標を求め、（320,240）を3D座標に変換した分だけずらします。カメラは注視点からZ軸沿いに－30.0fずらした位置に設定します。

以下は主人公のモデルを描画している部分です。3行目で3D座標を求めるときに、y座標を0.54fずらしています。3Dモデルの原点がモデルの中央にないので、ここで補正して意図通りの位置に表示されるようにしているのです。ずらす量はモデルに合わせて変える必要があります。

	//b2Vec2 pos = g_stage.hero.body->GetPosition();
	float angle = g_stage.hero.body->GetAngle();
	VECTOR heropos = VIW3D(pos.x, pos.y+0.54f);

	//ヒーロー描画
	StepAnimTime(&g_stage.heroanim, g_stage.herostate + g_stage.turnleft);
	MV1SetPosition(g_stage.heroanim.model, heropos);
	MV1SetRotationXYZ(g_stage.heroanim.model, VGet(-angle, -PHI_F/2, 0.0f));
	MV1DrawModel(g_stage.heroanim.model);

次回は表示範囲内のモデルだけを描画する方法について説明します。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

前回記事で公開したマリオブラザーズ風のゲームデモのグラフィックス処理について解説していきます。このゲームデモはもともと2D向けに作ったものです。3D版ではジャンプ処理のあたりを少し調整しましたが、基本的にはほとんど同じプログラムです。main.hの12行目にある定数B2D_DEBUG_DRAWのコメントを解除してから実行すると……

main.h

#include <DxLib.h>
#include <Box2D/Box2D.h>
#ifdef _DEBUG
	#pragma comment(lib, "Box2D_d.lib")
#endif
#ifndef _DEBUG
	#pragma comment(lib, "Box2D.lib")
#endif
#include "_dxdebugdraw.h"

//定数
#define B2D_DEBUG_DRAW
const int VELOCITYITE = 6;		//速度計算精度
const int POSITIONITE = 2;		//位置計算精度

3Dグラフィックスに重なってBox2Dのデバッグドロー（物理エンジンが管理しているボディやジョイントを表示するデバッグ用機能）が表示されます。これを見ると完全に2Dのプログラムであることがわかると思います。

©CRYPTON FUTURE MEDIA, INC.

Copyright (C) 2008-2010 唄音ウタProject, 飴屋／菖蒲 All Rights Reserved.

2Dと3Dの表示を合わせるには？

DXライブラリは2Dと3Dを混在して扱える（というより、もともと2D描画でも3Dグラフィックス機能を利用している）ので、同時に表示すること自体は普通にできます。しかし、座標軸の向きや単位などが違うので、まったく同じように動かすのはそれほど簡単ではありません。

ソースコードを見せる前に、ひとつひとつ理屈を説明していきましょう。

座標軸の方向の違いは比較的簡単に解決できます。2DのYの座標値にマイナスを付けて負の値にしてやればいいのです。2DのY座標値も3Dの負のY座標値も、絶対値が増えるほど下になります。この方式ならX座標値はそのまま使えるので、ちょっとした計算で簡単に座標変換できます。

次は座標やサイズに使う単位の問題について考えてみます。サンプルプログラムでは2D、3Dの座標系に加えて、もうひとつの座標系があります。それはBox2Dが使う物理演算用の座標系です。この座標系では単位としてメートルが使われています。

2Dグラフィックスではピクセルを単位として使うのがやりやすいので、2D版のプログラムではピクセルでキャラクタの位置や大きさを指定し、それをメートルに換算してからBox2Dに渡し、画面描画を行う際にまたピクセルに戻していました。具体的には「50ピクセル＝1メートル」としていたので、Box2Dに渡す前に50で割り、画面表示する前に50を掛けていたのです。

これに合わせて3Dグラフィックスを描画するのですが、前に説明したとおり3Dの座標系には単位はありません。ですから理論上はメートル単位やピクセル単位の座標値、サイズ値をそのまま使ってもいいことになります。

しかし、実際に使うとなると色々な問題が出てきます。ひとつはモデルのサイズです。PMDエディタで調べたところ、PMDねんどろ風初音ミクv1.1のサイズはだいたい「13」ということがわかりました。モデルを綺麗に見せるためには拡大縮小を避けたほうがいいので、原寸で表示して2Dとサイズが合うように調整するのが望ましいといえます。

ここでもうひとつ問題になってくるのは、元の2D描画のサイズが小さすぎることです。元のプログラムでは、マップを構成する1ブロックのサイズを36ピクセルで作成していましたが、これに合わせて3Dのモデルを表示すると、ディテールがほとんど見えなくなってしまいます。

色々検討した結果、2Dのデバッグドローの表示は元の1.5倍、3D描画はBox2Dのメートル単位の値を10倍して表示することにしました。

2Dのデバッグドローを1.5倍にする処理は、次のように定数DDRAWSCALERATEを定義しておいて……

_dxdebugdraw.h

const float DDRAWSCALERATE = 1.5f;	//表示のみ拡大したいときに使用
class DxDebugDraw :public b2DebugDraw{
private:
	b2Vec2 screen_pos;
	float WLDSC;
	inline int ColorValue(b2Color col){

座標、サイズ値をメートル単位から変換するときに、DDRAWSCALERATEを掛けるようにします。

_dxdebugdraw.cpp

	inline int ColorValue(b2Color col){
		return (int)(col.r * 0xFF0000 + col.g * 0xFF00 + col.b * 0xFF);
	}
	inline int VIWX(float32 x){
		return (int)(x * WLDSC * DDRAWSCALERATE - screen_pos.x);
	}
	inline int VIWY(float32 y){
		return (int)(y * WLDSC * DDRAWSCALERATE - screen_pos.y);
	}
	inline int VIW(float32 v){
		return (int)(v * WLDSC * DDRAWSCALERATE);
	}

3Dグラフィックスを描画する処理では、定数VIEW3DSCALEを定義しておいて……

main.h

//定数
#define B2D_DEBUG_DRAW
const int VELOCITYITE = 6;		//速度計算精度
const int POSITIONITE = 2;		//位置計算精度
const float GRAVITY_Y = 20.0f;	//重力加速度
const float WLDSC = 50.0f;		//世界倍率
const float SCREENAREA = 300.0f;//スクリーン範囲（ステージ外判定用）
const int SCROLL_LIMIT = 100;	//スクロール限界
const float VIEW3DSCALE = 10.0f;	//3D座標への変換に使うスケール値
const float WORLDZPOS = 320.0f;	//X軸の座標（全キャラ固定）
const float UNITSIZE_3D = 7.2f;	//3Dの1モデルのサイズ

2D座標から3D座標を求めるVIW3D関数を定義します。

_utils.cpp

//3D向けの座標変換関数
VECTOR VIW3D(float x, float y, float z3d){
	return VGet(x * VIEW3DSCALE, -y * VIEW3DSCALE, z3d);
}

この関数は、次のように2D座標から3D座標値を納めたVECTOR型の3D座標値を求めます。3つめの引数z3dは省略可能で、省略した場合は定数WORLDZPOS（320.0f）が使われます。

b2Vec2 pos = g_stage.hero.body->GetPosition();
VECTOR heropos = VIW3D(pos.x, pos.y+0.05f);
MV1SetPosition(g_stage.heroanim.model, heropos);
MV1DrawModel(g_stage.heroanim.model);

後はこの設定で2Dと3Dがうまく合うよう、SetupCamera_Ortho関数の値を調整します（今回は70を指定しています）。並行投影カメラを設定するSetupCamera_Orth関数については過去の記事を参照してください。

	SetCameraNearFar(10, 1000);
	SetupCamera_Ortho(70);

ちなみに並行投影カメラを使うと2Dっぽい描画になりますが、完全に一致するわけではありません。カメラの注視点（このゲームの場合は画面中央）に近い場所のみピタリと重なり、そこから遠くなるほど大きくずれていきます。ただし、3D描画全てが同じようにずれるので、注視点の位置で揃うように作成しておけば実用上の問題はありません。

さて、今回は少々ややこしい計算をしましたが、それは元々が2Dのプログラムだったからです。マップデータやキャラクターサイズなどをすべてピクセルで指定していたため、そこを変更するとなると全体にわたる微調整が必要です。

もし最初から3D前提で作るなら、最初からBox2Dのメートル単位で指定した方が簡単でいいかもしれません。

次回はスクロール処理と範囲内のみ描画する方法について解説します。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

ようやくマリオブラザーズ風のゲームデモができあがりました。元々2D前提で作ったものを3Dに変更したため、座標変換がややこしいことになってしまい、予想以上に手こずりました。取り急ぎソースコードと実行ファイルを公開しますが、解説はまた日を改めてとさせてください。

動画も用意したのですが、ゲームとキャプチャソフトを同時に実行できるスペックが無かったので、iPhoneで撮影しています。BGMはYoutubeの機能で合成したもので、実際のプログラムは無音です。操作方法はカーソルキーの左右とXキー、頭突きで動くブロックは動くだけでコインなどは出てきません。

http://www.youtube.com/watch?v=56foghugriI（クリックして動画再生）

©CRYPTON FUTURE MEDIA, INC.
Copyright (C) 2008-2010 唄音ウタProject, 飴屋／菖蒲 All Rights Reserved.

解説中で使用しているモデルはenamel toy box（ハッチさん運営）で公開されている「PMDねんどろ風初音ミクv1.1」と「PMDねんどろ風デフォ子v1.11」です。

ソースコードとコンパイル済みの実行ファイルは以下からダウンロードできます。

maori-bros3D_src.zip（要Visual C++ 2010 Express）

maori-bros3D_bin.zip（Windows用実行ファイル）

どちらもモデルファイルやテクスチャファイルを別途ダウンロードして、mediaフォルダ内にコピーする必要があります。「MmdDefoko1.11.pmd」は「MmdDefoko.pmd」にファイル名を変更しないといけません。ファイル名中にピリオドや数字があると、DXライブラリがモーションファイルを読み込んでくれなくなるためです。

以前の記事で説明したとおり、トゥーンマップのBMPファイルもコピーしておいてください。無くても動作しますが、トゥーン調表示になりません。

ちなみに、meidaフォルダ内に最初から入っているファイルは、こちらで作成したモーションファイルや地形のモデルファイル、マップファイルなどです。

次回は2Dゲームに合わせて3D描画を行う方法や、必要な範囲内だけ描画して処理を軽くする方法などを説明する予定です。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）。

前回は「立つ」「走る」「ジャンプ」のアニメーションをキー操作に合わせて切り替える方法を説明しましたが、一瞬でモデルの向きやポーズが変わってしまうため、不自然に見えるという問題がありました。これを解決するために、DXライブラリには複数のアニメーションをブレンドするMV1SetAttachAnimBlendRate関数が用意されています。ただし、再生時間の設定やアタッチ、デタッチといった処理に合わせて、さらにブレンド率の設定もしなければいけないので、どうスマートに組み込むかが工夫のしどころです。

今回の作例：いきなり「立つ」→「ジャンプ」へ切り替わるのではなく、切り替わり途中の中間段階のポーズが自動的に作られる
©CRYPTON FUTURE MEDIA, INC.
解説中で使用しているモデルは前回に続きenamel toy box（ハッチさん運営）で公開されている「PMDねんどろ風初音ミクv1.1」

※今回は拡大していないオリジナルのモデルをそのまま使用します。

アニメーションのブレンドの何が面倒なのか

今回も変更点が多めなので、完成状態のソースコードをダウンロードし、それを見ながら解説を読み進めてください。

DXB2D_3DTest_src06.zip（要Visual C++ 2010 Express）

このファイルをダウンロードして解凍したら、そのフォルダ内にmediaフォルダを作成し、モデルファイル、テクスチャファイル（texフォルダ）、トゥーンマップの画像ファイル、そして3つのモーションファイルをコピーします。要するに前回のmediaフォルダと同じ状態にしてください。もちろんVC++ディレクトリなどの設定も過去記事と同じように行う必要があります。

さて、本題のアニメーションのブレンドですが、それを設定するためのMV1SetAttachAnimBlenRate関数そのものはシンプルです。

int MV1SetAttachAnimBlendRate( int MHandle, int AttachIndex, float Rate ) ;

モデルハンドルMHandleとアタッチ番号AttachIndexを指定し、0.0f～1.0fのブレンド率Rateを指定するだけです。Rateで指定した割合だけ、アニメーションがモデルに影響を与えます。

ただし、アニメーションが滑らかに切り替わるようにするには、1つのモデルにアニメーションを2つアタッチし、古い方は100%（1.0f）→0%（0.0f）、新しい方は0%→100%となるようにブレンド率を変化させていかなければいけません。

これをアニメーションに再生時間を設定する処理や、その他のゲーム本編の処理と同時に行わなければいけないので、ちょっとばかりややこしいことになります。そこでサンプルのソースコードでは、アニメーションの再生処理を任せっきりにできる関数を作っています。

そのおかげで、DrawGameMain関数は14行目でStepAnimTimeという関数を呼び出すだけでアニメーションが完了するようになりました。

main.cpp

void DrawGameMain(){
	DrawBox(0,0,640,480, 0xFFDDDD, TRUE);
	//キー取得
	int key = GetJoypadInputState(DX_INPUT_KEY_PAD1);

	int herostate = HERO_STAND;
	if((key & PAD_INPUT_LEFT) || (key & PAD_INPUT_RIGHT)) {
		herostate = HERO_RUN;
	}
	if(key & PAD_INPUT_B){
		herostate = HERO_JUMP;
	}
	//アニメーション設定
	StepAnimTime(&g_stage.heroanim, herostate);

	//移動と表示
	MV1SetPosition(g_stage.heroanim.model, g_stage.heropos);
	MV1DrawModel(g_stage.heroanim.model) ;
	MV1SetPosition(g_stage.heroanim.model, VAdd(g_stage.heropos, VGet(15, 0, 15)) );
	MV1DrawModel(g_stage.heroanim.model) ;

アニメーション用情報を記憶する構造体を用意する

2つのアニメーションを同時にアタッチして徐々に切り替えるためには、最低でも2つのアタッチ番号を記憶する必要があります。個別の変数で管理するとわかりにくいので、アニメーション再生に必要な情報をまとめて記憶するAnimInfo構造体を定義することにしました。また、StageInfo構造体内にはAnimInfo型のメンバheroanimを定義します。

main.h

//アニメーション情報
struct AnimInfo{
	int model;		//モデルハンドル
	int anim;		//現在のアニメーション番号
	int attach;		//現在のアタッチ番号
	int oldanim;	//古いアニメーション番号
	int oldattach;	//古いアタッチ番号
	int starttime;	//現在のアニメーションの再生開始時刻
};
const int ANIMBLENDTIME = 500;	//ブレンドする時間（ミリ秒）
//ゲームデータ記録用構造体
struct StageInfo{
	int timerstart;			//待機タイマーの開始時刻
	int gamestarttime;		//ゲームの開始時間
	int gametime;			//ゲーム開始からの経過ミリ秒
	float mapsize_w, mapsize_h;	//マップサイズ
	int screen_x, screen_y;	//表示原点（スクロール用）

	VECTOR heropos;	//主人公の位置
	AnimInfo heroanim;	//主人公のアニメーション情報
};
//アニメーション用ポーズ定数
enum HeroState{HERO_STAND, HERO_RUN, HERO_JUMP};

AnimBlend構造体には、新旧2組みのアタッチ番号とアニメーション番号の他に、モデルハンドルとアニメーションの再生開始時刻を記憶します。再生開始時刻starttimeはブレンドする期間を制限するためのものです。

現在時刻－starttimeが定数ANIMBLENDTIMEより小さい間、アニメーションのブレンドを行うようにします。ANIMBLENDTIMEには500ミリ秒を指定しているので、0.5秒間掛けてアニメーションを切り替えることになります。

実際にサンプルを実行してみて長すぎると感じた場合は、ANIMBLENDTIMEを適当に減らしてください。

アニメーションを適切にデタッチするためのしくみ

アニメーションのブレンドが終わったら、適切に古いアニメーションをデタッチする必要があります。また、すでにデタッチをしているのに、繰り返しデタッチしないようにしなければいけません。そこで、AnimInfo構造体のメンバoldattachが－1ならデタッチ済みまたはアタッチ前なことを示すことにしました。

しかし、ゲーム開始時点ではoldattachは0で初期化されているので、アニメーションが再生される前に－1を代入しておく必要があります。また、ゲームの場合はゲーム本編→ゲームオーバーかタイトル画面→またゲーム本編……という流れになるので、直前のゲーム本編が終わるときにデタッチし損なった場合を考えて、ゲーム本編開始前にすべてのアニメーションをデタッチするしくみが必要です。

そこで、_utils.cpp（main.cppではありません）にInitAnimInfo関数とEraseAnimInfo関数という2つの関数を定義しました。

_utils.cpp

//モデルを複製し、初期状態のアニメーションを設定する
void InitAnimInfo(AnimInfo *ainfo, int srcmodel, int firstanim){
	ainfo->model = MV1DuplicateModel(srcmodel);
	ainfo->attach = MV1AttachAnim(ainfo->model, firstanim);
	ainfo->oldattach = -1;	//これは必須
}
//アニメーションをモデルごとを削除する
void EraseAnimInfo(AnimInfo *ainfo){
	if(ainfo->model != 0) MV1DeleteModel(ainfo->model);
	ainfo->model = 0;
}

InitAnimInfo関数はMV1DuplicateModel関数を使ってモデルの複製を作り、oldattachに－1を代入する処理を行います。

int MV1DuplicateModel( int SrcMHandle ) ;

MV1DuplicateModel関数でモデルハンドルを複製すると、容量を食うモデルデータやアニメーションデータは共有しつつも、アタッチの状態や変形情報を個別に持つ独立したモデルハンドルが作成されます。そこで、ファイルから読み込んだモデルデータそのものには手を付けず、その複製を使うようにすると、複製したモデルデータを削除するだけでアタッチ情報などをまとめて消すことができます。

ステージ情報の初期化を行うInitStage関数内ではInitAnimInfo関数とEraseAnimInfo関数を次のように使用しています。

main.cpp

//ステージ初期化
void InitStage(){
	//古いアニメーション情報を削除
	EraseAnimInfo(&g_stage.heroanim);

	//ゲームデータ全体のゼロ初期化
	ZeroMemory(&g_stage, sizeof(g_stage));
	//全ボディ・ジョイント削除
	DeleteAllBody();

	//主人公位置の初期化
	g_stage.heropos = VGet( 320.0f, 225.0f, -350.0f );
	//アニメーション情報を初期化
	InitAnimInfo(&g_stage.heroanim, g_images.hero, HERO_STAND);

	//ゲーム開始時刻の記録
	g_stage.gamestarttime = g_lasttime;
}

他の処理よりも前にEraseAnimInfo関数を呼び出して、前回ゲーム本編を実行したときに作成されたアタッチ情報などを複製モデルデータごと削除します。その後、InitAnimInfo関数を呼び出して、新たなモデルの複製を作成し、最初のアニメーションをアタッチします。

ブレンドしながらアニメーションを再生する

最後に本題のStepAnimTime関数について説明しましょう。この関数は必要に応じてアタッチ、デタッチ、ブレンド、再生時間の設定を行う関数です。少し長めなのでちょっとずつ説明していきます。

_utils.cpp

//アニメーション進行
void StepAnimTime(AnimInfo *ainfo, int animindex){
	//アタッチを変更する必要があるかどうかチェック
	if(ainfo->anim != animindex){
		//古い物をデタッチ
		if(ainfo->oldattach != -1){
			MV1DetachAnim(ainfo->model, ainfo->oldattach);
			ainfo->oldattach = -1;
		}
		//古い情報を待避
		ainfo->oldanim = ainfo->anim;
		ainfo->oldattach = ainfo->attach;
		//新しいアニメーションをアタッチ
		ainfo->anim = animindex;
		ainfo->attach = MV1AttachAnim(ainfo->model, ainfo->anim);
		//再生開始時間を記憶
		ainfo->starttime = g_stage.gametime;
	}

まず、AnimInfo構造体のアニメーション番号animと引数animindexを比較して、アタッチするアニメーションを切り替える必要があるかどうかをチェックします。ここまでは前回の解説と考え方は同じです。

ただし、単純に現在のものをデタッチして、新しいものをアタッチするのではなく、古いものが存在すればそれをデタッチしてから、現在のものをoldanimとoldattatchに移し、その後で新しいアニメーションをアタッチします。次の図のように玉突きするように置き換えていくイメージです。

最後に現在時間をAnimInfo構造体のstarttimeに記憶します。

続いて、現在のアニメーションに再生時間を設定します。この部分は関数を見やすくするために、StepAnimTimeSubという別関数に切り出しています。中でやっていることは前回記事で説明した再生時間の設定とほぼ同じです。

	//メインのアニメーションの時間を設定
	StepAnimTimeSub(ainfo->model, ainfo->attach);

次にブレンド処理が必要かどうかを判定します。この判定には先に説明した、「現在時間－starttime < ANIMBLENDTIME」という式を使います。

	//ブレンドが必要かどうか
	int time = g_stage.gametime - ainfo->starttime;
	if(time < ANIMBLENDTIME && ainfo->oldattach != -1){
		float brate = (float)time / (float)ANIMBLENDTIME;
		MV1SetAttachAnimBlendRate(ainfo->model, ainfo->attach, brate);
		//古いアニメーションのブレンドと時間設定
		MV1SetAttachAnimBlendRate(ainfo->model, ainfo->oldattach, 1.0f-brate);
		StepAnimTimeSub(ainfo->model, ainfo->oldattach);

ブレンド処理が必要と判定された場合は、「現在時間－starttime」をANIMBLENDTIMEで割ってブレンド率brateを求め、現在のアニメーションにはそのままbrateを設定し、古いアニメーションには「1.0f－brate」を設定していきます。これで徐々に古いアニメーションから現在のアニメーションへと変わって行きます。古いアニメーションも忘れずに再生時間を設定してアニメーションを進行させます。

ブレンド処理が不要と判定された場合は、以下の処理を行います。

	} else {
		//ブレンドレートを1にする
		MV1SetAttachAnimBlendRate(ainfo->model, ainfo->attach, 1.0f);
		//古いものをデタッチ
		if(ainfo->oldattach != -1){
			MV1DetachAnim(ainfo->model, ainfo->oldattach);
			ainfo->oldattach = -1;
		}
	}
}

現在のアニメーションのブレンド率を1に設定し、古いアニメーションがまだアタッチされたままなら、デタッチしてoldattachに－1を代入します。

これで簡単に複数の3Dアニメーションが扱えるようになりました。

これで3Dグラフィックスを使った2Dゲームを作るために必要な知識は、一通り説明が終わりました。次の最終記事ではその実例として、1ヶ月ほど前に作ったマリオもどきのテストプログラムと今回のプログラムを組み合わせ、MMDモデルを使ったマリオ風ゲームを作成します。

注：本記事で配布するソースコードにはモデルデータは含めませんので、それぞれの配布元から別途ダウンロードしてください（詳しくは初回記事を参照）

前回記事ではMikuMikuDanceを使ってモーションファイル（VMD形式）を作成しました。今回はそのモーションファイルをDXライブラリで読み込んで再生します。ゲームとまではいきませんが、キー操作に合わせて「立つ」「走る」「ジャンプする」の3つのモーションが切り替わるようにします。

今回の作例
©CRYPTON FUTURE MEDIA, INC.
解説中で使用しているモデルは前回に続きenamel toy box（ハッチさん運営）で公開されている「PMDねんどろ風初音ミクv1.1」

DXライブラリのアニメーション関数

これまではソースコードを少しずつ改造していく流れで説明していましたが、今回は変更点がちょっと多めです。そこで先に完成状態のソースコードをダウンロードし、それを見ながら解説を読み進めてください。

DXB2D_3DTest_src05.zip（要Visual C++ 2010 Express）

このファイルをダウンロードして解凍したら、そのフォルダ内にmediaフォルダを作成し、モデルファイル、テクスチャファイル（texフォルダ）、トゥーンマップの画像ファイル、そして3つのモーションファイルをコピーします。

MMD_Miku_O_vmd.zip（モーションファイル）

準備が終わったところで、DXライブラリのアニメーション関数について説明していきましょう。少々ややこしいので、まずは概要から説明していきます。

MV1LoadModel関数の説明によると、DXライブラリはモデルファイルの読み込みと同時にモーションファイルを読み込みます。本来はモーションデータを中に持ったモデルファイルを想定しているようですが、MikuMikuDanceではモデルはPMD、モーションはVMDに分かれています。そこで、PMDファイルを読み込む際に、同じフォルダ内に「モデルファイル名＋000から始まる3桁の連番.vmd」という名前のモーションファイルがあれば、それを読み込むしくみになっています。

読み込まれたモーションファイルは、モデルデータに紐づけされたアニメーションデータとなります。利用するときは、モデルハンドルとアニメーション番号を組み合わせて指定します。アニメーション番号はVMDファイルの名前に含まれていた連番です。

アニメーションは複数あるので、どれを使うかを選ばねばなりません。その処理のことを、アニメーションをモデルにアタッチする、といいます。次回の説明になりますが、複数のアニメーションをアタッチし、ブレンドして使うことも可能です。

MV1AttachAnim関数を使ってアニメーションをアタッチすると、アタッチ番号というものが返され、以降はそれを使ってアニメーションを制御します。アニメーション番号とアタッチ番号は混同しやすいので注意してください。アタッチ番号はモデルに複数のアニメーションがアタッチされているときにそれを区別するために使われるもので、1つしかアタッチしないときは常に0になります。

アタッチが終わったら、アニメーションを進行させます。そのためにゲームのメインループ中で、MV1SetAttachAnimTime関数を使ってアニメーションの再生時間を設定し続けなければいけません。たとえば、4秒間のアニメーションだったら、0～4まで増える数値を設定し続ける必要があります。これをどう処理するかがアニメーション処理のキモとなるでしょう。

再生時間を設定する際に注意が必要なのは、MikuMikuDanceでは1フレームの経過時間が1/30秒なのに対し、DXライブラリでは1フレーム＝1秒として処理する点です。そのため、DXライブラリで設定する再生時間は、通常の30倍のスピードで変化させる必要があります。

モーションの読み込みとアタッチ

では、実際のソースコードを見て、具体的な説明をしていきましょう。ゲーム進行中のデータを記憶するStageInfo構造体に現在再生しているアニメーション番号とアタッチ番号を記憶するメンバ変数を追加します。また、アニメーションを指定しやすくするために、HERO_STAND、HERO_RUN、HERO_JUMPという定数を持つHeroState列挙体を定義します。

main.h

//ゲームデータ記録用構造体
struct StageInfo{
	int timerstart;			//待機タイマーの開始時刻
	int gamestarttime;		//ゲームの開始時間
	int gametime;			//ゲーム開始からの経過ミリ秒
	float mapsize_w, mapsize_h;	//マップサイズ
	int screen_x, screen_y;	//表示原点（スクロール用）

	VECTOR heropos;	//主人公の位置
	int hero_anim;	//主人公のアニメーション番号
	int hero_attach;//アタッチ番号
};
//アニメーション用ポーズ定数
enum HeroState{HERO_STAND, HERO_RUN, HERO_JUMP};

以前のソースコードでは、LoadFiles関数内でモデルデータを読み込んだ後、拡大したり輪郭線の幅を変更したりしていましたが、今回からカメラの位置で大きさを調整することにしたのでそれらは必要ありません。おかげでかなりシンプルになります。

main.cpp

//ファイルの読み込み
int LoadFiles(){
	//ファイル読み込み処理をここに書く
	g_images.hero = MV1LoadModel("media\\MMD_Miku_O.pmd");
	if(g_images.hero == -1) return -1;
	//読み込み成功
	return 1;
}

ステージ開始時に呼び出されるInitStage関数の中で、「立つ」アニメーションをアタッチします。

main.cpp

//ステージ初期化
void InitStage(){
	//ゲームデータ全体のゼロ初期化
	ZeroMemory(&g_stage, sizeof(g_stage));
	//全ボディ・ジョイント削除
	DeleteAllBody();

	//主人公位置の初期化
	g_stage.heropos = VGet( 320.0f, 225.0f, -350.0f );
	//初期アニメ設定
	g_stage.hero_attach = MV1AttachAnim(g_images.hero, HERO_STAND);	

	//ゲーム開始時刻の記録
	g_stage.gamestarttime = g_lasttime;
}

11行目でMV1AttachAnim関数に2つの引数を指定していますが、省略可能なものを含めると4つの引数を指定できます。

アニメーションをアタッチする

int MV1AttachAnim( int MHandle, int AnimIndex, int AnimSrcMHandle, int NameCheck ) ;

引数MHandleはモデルハンドル、AnimIndexはアニメーション番号です。残りの2つの引数は、他のモデルが持つアニメーションをアタッチするときに使います。AnimSrcMHandleにはアニメーションを持つモデルのハンドルを指定します。モデルのフレーム（MikuMikuDanceでのボーンのこと）の構造が違うとうまくアタッチできない場合がありますが、NameCheckにTRUEを指定すると、フレームの名前が一致しない場合はアタッチされないようになります。

キー操作に合わせてアニメーションを切り替える

アニメーションの再生処理はDrawGameMain関数の中にあります。長めなので少しずつ見ていきます。まずはキーの状態に合わせて再生するアニメーションを切り替える部分です。

main.cpp

void DrawGameMain(){
	DrawBox(0,0,640,480, 0xFFDDDD, TRUE);
	//キー取得
	int key = GetJoypadInputState(DX_INPUT_KEY_PAD1);

	int herostate = HERO_STAND;
	if((key & PAD_INPUT_LEFT) || (key & PAD_INPUT_RIGHT)) {
		herostate = HERO_RUN;
	}
	if(key & PAD_INPUT_B){
		herostate = HERO_JUMP;
	}

何も押していないときは変数herostateにHERO_STANDが代入され、左右のカーソルキーを押したときはHERO_RUN、Xキー（ジョイパッドならBボタン）が押されたときはHERO_JUMPが代入されるようにしています。

続いてアニメーションのアタッチです。herostateの値に応じ、必要ならアタッチするアニメーションを切り替えます。現在再生しているアニメーション番号はg_stageのメンバhero_animに記憶しているので、それとherostateを比較すれば、切り替えが必要かどうかがわかります。

main.cpp

	//アニメーション設定
	//現在のアニメーションのアタッチ番号取得
	//アタッチを変更する必要があるかどうかチェック
	if(g_stage.hero_anim != herostate){
		//古い物をデタッチ
		MV1DetachAnim(g_images.hero, g_stage.hero_attach);
		//新しいアニメーションをアタッチ
		g_stage.hero_anim = herostate;
		g_stage.hero_attach = MV1AttachAnim(g_images.hero, g_stage.hero_anim);
	}

新しいアニメーションをアタッチする前に、古いアニメーションを外さなければいけません。その処理をデタッチといいます。

int MV1DetachAnim( int MHandle, int AttachIndex ) ;

MV1DetachAnim関数の引数はモデルハンドルとアタッチ番号です。アニメーション番号ではありませんので間違わないよう注意してください。

デタッチした後は、新しいアニメーションをアタッチし、アニメーション番号とアタッチ番号をg_stageに記憶します。

アニメーションの再生時間を進める

アニメーションの再生時間は、実際の時間進行と同じスピードで、0～終了時間まで設定し続けなければいけません。ゲーム開始からの経過時間がg_stageのメンバgametimeに記憶しているので、それをうまく使うようにします。

	//時間進行
	//総時間取得
	int totaltime = (int)(MV1GetAttachAnimTotalTime(g_images.hero, g_stage.hero_attach) * 1000.0f);
	//アニメーション時間を算出して設定（MMDでは1フレーム＝1/30秒なので補正が必要）
	float animtime;
	if(totaltime == 0) animtime = 0.0f;
	else {
		animtime = (float)(g_stage.gametime * 30 % totaltime) / 1000.0f;
	}
	MV1SetAttachAnimTime(g_images.hero, g_stage.hero_attach, animtime);
	clsDx();printfDx("%6.3f\n", animtime);//時間チェック
	printfDx("%d", g_stage.hero_attach);//アタッチ番号チェック

まず、MV1GetAttachAnimTotalTIme関数を使ってアニメーションの総時間を取得します（3行目）。この関数はfloat型の値を返しますが、int型のミリ秒と組み合わせて計算させたいので、1000を掛けてint型にキャストします。

float MV1GetAttachAnimTotalTime( int MHandle, int AttachIndex ) ;

もし総時間が0（1つのフレームしかない状態）だった場合、設定する再生時間も0にしないとエラーになります。そのための確認を6行目で行っています。

続いて次の計算式で再生時間を求めます。

gametimeに30を掛けてからtotaltimeで割った余りを求めることで、0～totaltimeまで変化する数値を取得します。それを1000で割った実数にすると再生時間が求められます。先に説明したとおり、経過時間に30を掛けるところがポイントです。求められる再生時間は0～totaltimeですが、実際の30倍の速度で時間が変化します。

最後にMV1SetAttachAnimTime関数で再生時間を設定します。

int MV1SetAttachAnimTime( int MHandle, int AttachIndex, float Time ) ;

ここまでで重要な部分はおしまいです。後はこれまで説明したものと同じように、モデルの移動・表示、カメラの設定を行います。標準は右方向からの視点ですが、Cキーを押すと正面からの視点に変わるようにしています。

	//移動と表示
	MV1SetPosition(g_images.hero, g_stage.heropos);
	MV1DrawModel(g_images.hero) ;
	MV1SetPosition(g_images.hero, VAdd(g_stage.heropos, VGet(15, 0, 15)) );
	MV1DrawModel(g_images.hero) ;
	MV1SetPosition(g_images.hero, VAdd(g_stage.heropos, VGet(-15, 0, 15)) );
	MV1DrawModel(g_images.hero) ;

	//カメラの設定
	SetCameraPositionAndTarget_UpVecY(VGet(270.0f, 240.0f, -345.0f),
		VAdd(g_stage.heropos, VGet(0, 1, 10)) );
	//ちょっとした視点変更
	if(key & PAD_INPUT_C){
		SetCameraPositionAndTarget_UpVecY(VGet(320.0f, 240.0f, -385.0f),
			VAdd(g_stage.heropos, VGet(0, 1, 25)) );
	}
	SetCameraNearFar(10, 1000);
	SetupCamera_Perspective( PHI_F / 5 );
	//SetupCamera_Ortho(150);
}

実行すると最初は立ちモーションで再生されます。カーソルの左右キーのどちらかを押すと走るモーション、Xキーを押すとジャンプします。

Cキーを押すと正面からの視点に切り替わります。左上の数値は計算で求めた再生時間とアタッチ番号です。

これで目的は果たせていますが、アニメーションの切り替わりがぎこちないですね。そこで次回はアニメーションをブレンドして切り替わりをより滑らかにする方法を説明します。