//======================================================================
//          IrisGXB.h
//            IRISディスプレイリストをバッファ(主にデータTCM)へ生成
//
//          Copyright (C) 2002-2003 NINTENDO Co.,Ltd.
//======================================================================
#ifndef _IRIS_GXB_H
#define _IRIS_GXB_H

#ifdef __cplusplus
extern "C" {
#endif


#include <IrisTarget.h>
#include <IrisMacro.h>
#include <IrisSinTable.h>


//----------------------------------------------------------------------
//          ディスプレイリストＣＰＵ転送
//
//・ディスプレイリストをCPUにてジオメトリコマンドFIFOへ転送します。
//
//・引数：
//  startp  ディスプレイリストバッファの先頭ポインタ
//  endp    ディスプレイリストバッファの終了ポインタ
//
//・戻り値：なし
//
//※TCM上のディスプレイリストはDMA転送できません。
//----------------------------------------------------------------------

void GXB_CallList(u32 *startp, u32 *endp);


//----------------------------------------------------------------------
//          ビューポート設定
//
//・BG0面上におけるビューポートの左下座標と右上座標を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  startX  左下X座標（8bit）
//  startY  左下Y座標（ 〃 ）
//  endX    右上X座標（ 〃 ）
//  endY    右上Y座標（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Viewport(bufp, startX, startY, endX, endY)		\
{															\
	(bufp)[0] = GXOP_VIEWPORT;								\
	(bufp)[1] = (u32 )(startX) << VIEWPORT_START_X_SHIFT	\
			  | (u32 )(startY) << VIEWPORT_START_Y_SHIFT	\
			  | (u32 )(endX)   << VIEWPORT_END_X_SHIFT		\
			  | (u32 )(endY)   << VIEWPORT_END_Y_SHIFT;		\
															\
	(bufp) += (1 + GXOP_VIEWPORT_NPARAMS);					\
}


//======================================================================
//          行列コマンド群
//======================================================================

//----------------------------------------------------------------------
//          行列モード設定
//
//・行列コマンドで操作するカレント行列を指定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  mode    行列モード
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_MtxMode(bufp, mode)								\
{															\
	(bufp)[0] = GXOP_MTX_MODE;								\
	(bufp)[1] = (mode);										\
															\
	(bufp) += (1 + GXOP_MTX_MODE_NPARAMS);					\
}

//----------------------------------------------------------------------
//          カレント行列のプッシュ
//
//・カレント行列を行列スタックへ退避する
//  ディスプレイリストを生成します。
//・行列スタックポインタは１つ進みます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PushMtx(bufp)									\
{															\
	(bufp)[0] = GXOP_MTX_PUSH;								\
															\
	(bufp) += (1 + GXOP_MTX_PUSH_NPARAMS);					\
}

//----------------------------------------------------------------------
//          カレント行列のポップ
//
//・カレント行列を行列スタックから復元する
//  ディスプレイリストを生成します。
//・行列スタックポインタは指定した相対位置へ移動します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  relPos  相対位置（-30 〜 31）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PopMtx(bufp, relPos)							\
{															\
	(bufp)[0] = GXOP_MTX_POP;								\
	(bufp)[1] = (relPos);									\
															\
	(bufp) += (1 + GXOP_MTX_POP_NPARAMS);					\
}

//----------------------------------------------------------------------
//          カレント行列のストア
//
//・カレント行列を行列スタックの指定位置へ格納する
//  ディスプレイリストを生成します。
//・行列スタックポインタは移動しません。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  index   インデックス（0 〜 30）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_StoreMtx(bufp, index)							\
{															\
	(bufp)[0] = GXOP_MTX_STORE;								\
	(bufp)[1] = (index);									\
															\
	(bufp) += (1 + GXOP_MTX_STORE_NPARAMS);					\
}

//----------------------------------------------------------------------
//          カレント行列のリストア
//
//・カレント行列を行列スタックの指定位置から取り出す
//  ディスプレイリストを生成します。
//・行列スタックポインタは移動しません。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  index   インデックス（0 〜 30）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_RestoreMtx(bufp, index)							\
{															\
	(bufp)[0] = GXOP_MTX_RESTORE;							\
	(bufp)[1] = (index);									\
															\
	(bufp) += (1 + GXOP_MTX_RESTORE_NPARAMS);				\
}


//----------------------------------------------------------------------
//          単位行列への初期化
//
//・カレント行列を単位行列に初期化する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Identity(bufp)									\
{															\
	(bufp)[0] = GXOP_MTX_IDENTITY;							\
															\
	(bufp) += (1 + GXOP_MTX_IDENTITY_NPARAMS);				\
}

//----------------------------------------------------------------------
//          平行移動行列の適用
//
//・カレント行列に平行移動行列を乗算する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       X成分
//  y       Y成分
//  z       Z成分
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate(bufp, x, y, z)						\
{															\
    (bufp)[0] = GXOP_MTX_TRANS;								\
															\
    (bufp)[1] = (x);										\
    (bufp)[2] = (y);										\
    (bufp)[3] = (z);										\
															\
    (bufp) += (1 + GXOP_MTX_TRANS_NPARAMS);					\
}

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define _GXB_TranslateBefore(bufp, x, y, z)					\
{															\
    (bufp)[0] = (x);										\
    (bufp)[1] = (y);										\
    (bufp)[2] = (z);										\
															\
    (bufp) += GXOP_MTX_TRANS_NPARAMS;						\
}


//----------------------------------------------------------------------
//          カレント行列へのロード
//
//・カレント行列に指定した行列を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  srcp    ロードする行列のポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LoadMtx(bufp, srcp)                             \
{															\
	(bufp)[0] = GXOP_MTX_LOAD_4x3;							\
															\
	(bufp) = _GXB_SetMtx(&(bufp)[1], srcp);					\
}
#define GXB_LoadMtx33(bufp, srcp)                           \
{															\
	(bufp)[0] = GXOP_MTX_LOAD_4x3;							\
															\
	(bufp) = _GXB_SetMtx33(&(bufp)[1], srcp);				\
	*(bufp)++ = 0;											\
	*(bufp)++ = 0;											\
	*(bufp)++ = 0;											\
}
#define GXB_LoadMtx44(bufp, srcp)                           \
{															\
	(bufp)[0] = GXOP_MTX_LOAD_4x4;							\
															\
	(bufp) = _GXB_SetMtx44(&(bufp)[1], srcp);				\
}

u32 *_GXB_SetMtx(  u32 *bufp, const Mtx   *srcp);
u32 *_GXB_SetMtx33(u32 *bufp, const Mtx33 *srcp);
u32 *_GXB_SetMtx44(u32 *bufp, const Mtx44 *srcp);

//----------------------------------------------------------------------
//          一般行列とカレント行列の乗算
//
//・カレント行列に指定した行列を乗算する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  srcp    適用する行列のポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_MultMtx(bufp, srcp)                             \
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x3;							\
															\
	(bufp) = _GXB_SetMtx(&(bufp)[1], srcp);					\
}
#define GXB_MultMtx33(bufp, srcp)                           \
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_SetMtx33(&(bufp)[1], srcp);				\
}
#define GXB_MultMtx44(bufp, srcp)                           \
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x4;							\
															\
	(bufp) = _GXB_SetMtx44(&(bufp)[1], srcp);				\
}

//----------------------------------------------------------------------
//          平行移動行列を適用後に一般行列を乗算
//
//・カレント行列へ平行移動行列と一般行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//
//・GXB_Translate()＋GXB_MultMtx33() よりもジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       X成分
//  y       Y成分
//  z       Z成分
//  srcp    適用する3x3行列のポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate2MultMtx33(bufp, x, y, z, srcp)		\
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x3;							\
															\
	(bufp) = _GXB_SetMtx33(&(bufp)[1], srcp);				\
    _GXB_TranslateBefore(bufp, x, y, z);					\
}


//----------------------------------------------------------------------
//          転置行列の適用
//
//・カレント行列に指定した行列の転置行列を乗算する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  srcp    転置前の行列のポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TransposeMtx(bufp, srcp)						\
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x3;							\
															\
	(bufp) = _GXB_TransposeMtx(&(bufp)[1], srcp);			\
}
#define GXB_TransposeMtx33(bufp, srcp)						\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_TransposeMtx33(&(bufp)[1], srcp);			\
}
#define GXB_TransposeMtx44(bufp, srcp)						\
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x4;							\
															\
	(bufp) = _GXB_TransposeMtx44(&(bufp)[1], srcp);			\
}

u32 *_GXB_TransposeMtx(  u32 *bufp, const Mtx   *srcp);
u32 *_GXB_TransposeMtx33(u32 *bufp, const Mtx33 *srcp);
u32 *_GXB_TransposeMtx44(u32 *bufp, const Mtx44 *srcp);

//----------------------------------------------------------------------
//          平行移動行列を適用後に転置行列を適用
//
//・カレント行列へ平行移動行列と転置行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//
//・GXB_Translate()＋GXB_TransposeMtx33() よりもジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       平行移動のX成分
//  y       平行移動のY成分
//  z       平行移動のZ成分
//  srcp    転置前の3x3行列のポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate2TransposeMtx33(bufp, x, y, z, srcp)	\
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x3;							\
															\
	(bufp) = _GXB_TransposeMtx33(&(bufp)[1], srcp);			\
    _GXB_TranslateBefore(bufp, x, y, z);					\
}


//----------------------------------------------------------------------
//          スケール行列の適用（位置座標行列のみ）
//
//・カレント行列にスケール行列を乗算する
//  ディスプレイリストを生成します。
//・行列モードが Position・Vector 同時設定モードの場合でも
//  位置座標行列のみに適用されます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       X成分
//  y       Y成分
//  z       Z成分
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Scale(bufp, x, y, z)							\
{															\
    (bufp)[0] = GXOP_MTX_SCALE;								\
															\
    (bufp)[1] = (x) >>VG_SFT_DF;							\
    (bufp)[2] = (y) >>VG_SFT_DF;							\
    (bufp)[3] = (z) >>VG_SFT_DF;							\
															\
    (bufp) += (1 + GXOP_MTX_SCALE_NPARAMS);					\
}

//----------------------------------------------------------------------
//          スケール行列の適用（位置座標行列＆方向ベクトル行列）
//
//・カレント行列にスケール行列を乗算する
//  ディスプレイリストを生成します。
//・行列モードが Position・Vector 同時設定モードの場合には
//  位置座標行列と方向ベクトル行列の両方に適用されます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       X成分
//  y       Y成分
//  z       Z成分
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_ScaleWithVector(bufp, x, y, z)					\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_ScaleWithVector(&(bufp)[1], x, y, z);		\
}

u32 *_GXB_ScaleWithVector(u32 *bufp, s32 x, s32 y, s32 z);

//----------------------------------------------------------------------
//          平行移動行列を適用後に
//          スケール行列を適用（位置座標行列＆方向ベクトル行列）
//
//・カレント行列へ平行移動行列とスケール行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//・行列モードが Position・Vector 同時設定モードの場合には
//  位置座標行列と方向ベクトル行列の両方に適用されます。
//
//・GXB_Translate()＋GXB_ScaleWithVector() よりもジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  xT      平行移動のX成分
//  yT      平行移動のY成分
//  zT      平行移動のZ成分
//  xS      スケールのX成分
//  yS      スケールのY成分
//  zS      スケールのZ成分
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate2ScaleWithVector(bufp, xT, yT, zT, xS, yS, zS)	\
{																	\
	(bufp)[0] = GXOP_MTX_MULT_4x3;									\
																	\
	(bufp) = _GXB_ScaleWithVector(&(bufp)[1], xS, yS, zS);			\
    _GXB_TranslateBefore(bufp, xT, yT, zT);							\
}


//----------------------------------------------------------------------
//          主軸回転行列の適用
//
//・カレント行列に各主軸回りに回転する行列を乗算する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  theta   回転角度［256｜1024｜4096段階］
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_RotateX(bufp, theta)				GXB_RotatePriv(bufp, X, SIN_NDIV_DEFAULT, theta)
#define GXB_RotateY(bufp, theta)				GXB_RotatePriv(bufp, Y, SIN_NDIV_DEFAULT, theta)
#define GXB_RotateZ(bufp, theta)				GXB_RotatePriv(bufp, Z, SIN_NDIV_DEFAULT, theta)

#define GXB_RotateX256(bufp, theta)				GXB_RotatePriv(bufp, X, 256,  theta)
#define GXB_RotateY256(bufp, theta)				GXB_RotatePriv(bufp, Y, 256,  theta)
#define GXB_RotateZ256(bufp, theta)				GXB_RotatePriv(bufp, Z, 256,  theta)
#define GXB_RotateX1024(bufp, theta)			GXB_RotatePriv(bufp, X, 1024, theta)
#define GXB_RotateY1024(bufp, theta)			GXB_RotatePriv(bufp, Y, 1024, theta)
#define GXB_RotateZ1024(bufp, theta)			GXB_RotatePriv(bufp, Z, 1024, theta)
#define GXB_RotateX4096(bufp, theta)			GXB_RotatePriv(bufp, X, 4096, theta)
#define GXB_RotateY4096(bufp, theta)			GXB_RotatePriv(bufp, Y, 4096, theta)
#define GXB_RotateZ4096(bufp, theta)			GXB_RotatePriv(bufp, Z, 4096, theta)

u32 *_GXB_RotateX256(u32 *bufp, u32 theta);
u32 *_GXB_RotateY256(u32 *bufp, u32 theta);
u32 *_GXB_RotateZ256(u32 *bufp, u32 theta);
u32 *_GXB_RotateX1024(u32 *bufp, u32 theta);
u32 *_GXB_RotateY1024(u32 *bufp, u32 theta);
u32 *_GXB_RotateZ1024(u32 *bufp, u32 theta);
u32 *_GXB_RotateX4096(u32 *bufp, u32 theta);
u32 *_GXB_RotateY4096(u32 *bufp, u32 theta);
u32 *_GXB_RotateZ4096(u32 *bufp, u32 theta);

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_RotatePriv(bufp, axis, ndiv, theta)				\
		GXB_RotateNDiv(bufp, axis, ndiv, theta)
#define GXB_RotateNDiv(bufp, axis, ndiv, theta)				\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_Rotate##axis##ndiv(&(bufp)[1], theta);	\
}

//----------------------------------------------------------------------
//          平行移動行列を適用後に主軸回転行列を適用
//
//・カレント行列へ平行移動行列と主軸回転行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//
//・GXB_Translate()＋GXB_Rotate[X|Y|Z][256|1024|4096]() よりも
//  ジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       平行移動のX成分
//  y       平行移動のY成分
//  z       平行移動のZ成分
//  theta   回転角度［256｜1024｜4096段階］
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate2RotateX(bufp, x, y, z, theta)			GXB_Translate2RotatePriv(bufp, x, y, z, X, SIN_NDIV_DEFAULT, theta)
#define GXB_Translate2RotateY(bufp, x, y, z, theta)			GXB_Translate2RotatePriv(bufp, x, y, z, Y, SIN_NDIV_DEFAULT, theta)
#define GXB_Translate2RotateZ(bufp, x, y, z, theta)			GXB_Translate2RotatePriv(bufp, x, y, z, Z, SIN_NDIV_DEFAULT, theta)

#define GXB_Translate2RotateX256(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, X, 256,  theta)
#define GXB_Translate2RotateY256(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Y, 256,  theta)
#define GXB_Translate2RotateZ256(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Z, 256,  theta)
#define GXB_Translate2RotateX1024(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, X, 1024, theta)
#define GXB_Translate2RotateY1024(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Y, 1024, theta)
#define GXB_Translate2RotateZ1024(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Z, 1024, theta)
#define GXB_Translate2RotateX4096(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, X, 4096, theta)
#define GXB_Translate2RotateY4096(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Y, 4096, theta)
#define GXB_Translate2RotateZ4096(bufp, x, y, z, theta)		GXB_Translate2RotatePriv(bufp, x, y, z, Z, 4096, theta)

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_Translate2RotatePriv(bufp, x, y, z, axis, ndiv, theta)		\
		GXB_Translate2RotateNDiv(bufp, x, y, z, axis, ndiv, theta)
#define GXB_Translate2RotateNDiv(bufp, x, y, z, axis, ndiv, theta)		\
{																		\
	(bufp)[0] = GXOP_MTX_MULT_4x3;										\
																		\
	(bufp) = _GXB_Rotate##axis##ndiv(&(bufp)[1], theta);				\
    _GXB_TranslateBefore(bufp, x, y, z);								\
}

//----------------------------------------------------------------------
//          主軸回転行列（三角関数による回転角指定）の適用
//
//・カレント行列に各主軸回りに回転する行列を乗算する
//  ディスプレイリストを生成します。
//・回転角度はサインとコサインにて指定します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  sinA    回転角度のサイン
//  cosA    回転角度のコサイン
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_RotateXSinCos(bufp, sinA, cosA)					\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_RotateXSinCos(&(bufp)[1], sinA, cosA);	\
}
#define GXB_RotateYSinCos(bufp, sinA, cosA)					\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_RotateYSinCos(&(bufp)[1], sinA, cosA);	\
}
#define GXB_RotateZSinCos(bufp, sinA, cosA)					\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_RotateZSinCos(&(bufp)[1], sinA, cosA);	\
}

u32 *_GXB_RotateXSinCos(u32 *bufp, s32 sinA, s32 cosA);
u32 *_GXB_RotateYSinCos(u32 *bufp, s32 sinA, s32 cosA);
u32 *_GXB_RotateZSinCos(u32 *bufp, s32 sinA, s32 cosA);

//----------------------------------------------------------------------
//          平行移動行列を適用後に
//          主軸回転行列（三角関数による回転角指定）を適用
//
//・カレント行列へ平行移動行列と主軸回転行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//・回転角度はサインとコサインにて指定します。
//
//・GXB_Translate()＋GXB_Rotate[X|Y|Z]SinCos() よりも
//  ジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       平行移動のX成分
//  y       平行移動のY成分
//  z       平行移動のZ成分
//  sinA    回転角度のサイン
//  cosA    回転角度のコサイン
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Translate2RotateXSinCos(bufp, x, y, z, sinA, cosA)		GXB_Translate2RotateSinCosPriv(bufp, x, y, z, X, sinA, cosA)
#define GXB_Translate2RotateYSinCos(bufp, x, y, z, sinA, cosA)		GXB_Translate2RotateSinCosPriv(bufp, x, y, z, Y, sinA, cosA)
#define GXB_Translate2RotateZSinCos(bufp, x, y, z, sinA, cosA)		GXB_Translate2RotateSinCosPriv(bufp, x, y, z, Z, sinA, cosA)

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_Translate2RotateSinCosPriv(bufp, x, y, z, axis, sinA, cosA)		\
		GXB_Translate2RotateSinCosNDiv(bufp, x, y, z, axis, sinA, cosA)
#define GXB_Translate2RotateSinCosNDiv(bufp, x, y, z, axis, sinA, cosA)		\
{																			\
	(bufp)[0] = GXOP_MTX_MULT_4x3;											\
																			\
	(bufp) = _GXB_RotateZSinCos(&(bufp)[1], sinA, cosA);					\
    _GXB_TranslateBefore(bufp, x, y, z);									\
}


//----------------------------------------------------------------------
//          任意軸回転行列の適用
//
//・カレント行列に任意のベクトルを軸として回転する行列を乗算する
//  ディスプレイリストを生成します。
//
//・通常版は関数内で平方根演算器と除算器を使用しますが、高速版は使用しません
//  （高速版には単位ベクトルを渡して下さい）。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  axisp   回転軸ベクトルのポインタ
//  theta   回転角度［256｜1024｜4096段階］
//
//・戻り値：なし
//
//※通常版は平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_RotateAxis(    bufp, axisp, theta)			GXB_RotateAxisPriv(    bufp, SIN_NDIV_DEFAULT, axisp, theta)
#define GXB_RotateAxisFast(bufp, axisp, theta)			GXB_RotateAxisPrivFast(bufp, SIN_NDIV_DEFAULT, axisp, theta)

#define GXB_RotateAxis256(    bufp, axisp, theta)		GXB_RotateAxisPriv(    bufp, 256,  axisp, theta)
#define GXB_RotateAxis256Fast(bufp, axisp, theta)		GXB_RotateAxisPrivFast(bufp, 256,  axisp, theta)
#define GXB_RotateAxis1024(    bufp, axisp, theta)		GXB_RotateAxisPriv(    bufp, 1024, axisp, theta)
#define GXB_RotateAxis1024Fast(bufp, axisp, theta)		GXB_RotateAxisPrivFast(bufp, 1024, axisp, theta)
#define GXB_RotateAxis4096(    bufp, axisp, theta)		GXB_RotateAxisPriv(    bufp, 4096, axisp, theta)
#define GXB_RotateAxis4096Fast(bufp, axisp, theta)		GXB_RotateAxisPrivFast(bufp, 4096, axisp, theta)

u32 *_GXB_RotateAxis256(    u32 *bufp, const Vec *axisp, u32 theta);
u32 *_GXB_RotateAxis256Fast(u32 *bufp, const Vec *axisp, u32 theta);
u32 *_GXB_RotateAxis1024(    u32 *bufp, const Vec *axisp, u32 theta);
u32 *_GXB_RotateAxis1024Fast(u32 *bufp, const Vec *axisp, u32 theta);
u32 *_GXB_RotateAxis4096(    u32 *bufp, const Vec *axisp, u32 theta);
u32 *_GXB_RotateAxis4096Fast(u32 *bufp, const Vec *axisp, u32 theta);

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_RotateAxisPriv(    bufp, ndiv, axisp, theta)			\
		GXB_RotateAxisNDiv(    bufp, ndiv, axisp, theta)
#define GXB_RotateAxisNDiv(    bufp, ndiv, axisp, theta)			\
{																	\
	(bufp)[0] = GXOP_MTX_MULT_3x3;									\
																	\
	(bufp) = _GXB_RotateAxis##ndiv(&(bufp)[1], axisp, theta);		\
}
#define GXB_RotateAxisPrivFast(bufp, ndiv, axisp, theta)			\
		GXB_RotateAxisNDivFast(bufp, ndiv, axisp, theta)
#define GXB_RotateAxisNDivFast(bufp, ndiv, axisp, theta)			\
{																	\
	(bufp)[0] = GXOP_MTX_MULT_3x3;									\
																	\
	(bufp) = _GXB_RotateAxis##ndiv##Fast(&(bufp)[1], axisp, theta);	\
}

//----------------------------------------------------------------------
//          平行移動行列を適用後に任意軸回転行列を適用
//
//・カレント行列へ平行移動行列と任意軸回転行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//
//・通常版は関数内で平方根演算器と除算器を使用しますが、高速版は使用しません
//  （高速版には単位ベクトルを渡して下さい）。
//・GXB_Translate()＋GXB_RotateAxis[256|1024|4096][Fast]() よりも
//  ジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       平行移動のX成分
//  y       平行移動のY成分
//  z       平行移動のZ成分
//  axisp   回転軸ベクトルのポインタ
//  theta   回転角度［256｜1024｜4096段階］
//
//・戻り値：なし
//
//※通常版は平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Translate2RotateAxis(    bufp, x, y, z, axisp, theta)		GXB_Translate2RotateAxisPriv(    bufp, x, y, z, SIN_NDIV_DEFAULT, axisp, theta)
#define GXB_Translate2RotateAxisFast(bufp, x, y, z, axisp, theta)		GXB_Translate2RotateAxisPrivFast(bufp, x, y, z, SIN_NDIV_DEFAULT, axisp, theta)

#define GXB_Translate2RotateAxis256(    bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPriv(    bufp, x, y, z, 256,  axisp, theta)
#define GXB_Translate2RotateAxis256Fast(bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPrivFast(bufp, x, y, z, 256,  axisp, theta)
#define GXB_Translate2RotateAxis1024(    bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPriv(    bufp, x, y, z, 1024, axisp, theta)
#define GXB_Translate2RotateAxis1024Fast(bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPrivFast(bufp, x, y, z, 1024, axisp, theta)
#define GXB_Translate2RotateAxis4096(    bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPriv(    bufp, x, y, z, 4096, axisp, theta)
#define GXB_Translate2RotateAxis4096Fast(bufp, x, y, z, axisp, theta)	GXB_Translate2RotateAxisPrivFast(bufp, x, y, z, 4096, axisp, theta)

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_Translate2RotateAxisPriv(    bufp, x, y, z, ndiv, axisp, theta)	\
		GXB_Translate2RotateAxisNDiv(    bufp, x, y, z, ndiv, axisp, theta)
#define GXB_Translate2RotateAxisNDiv(    bufp, x, y, z, ndiv, axisp, theta)	\
{																			\
	(bufp)[0] = GXOP_MTX_MULT_4x3;											\
																			\
	(bufp) = _GXB_RotateAxis##ndiv(&(bufp)[1], axisp, theta);				\
    _GXB_TranslateBefore(bufp, x, y, z);									\
}
#define GXB_Translate2RotateAxisPrivFast(bufp, x, y, z, ndiv, axisp, theta)	\
		GXB_Translate2RotateAxisNDivFast(bufp, x, y, z, ndiv, axisp, theta)
#define GXB_Translate2RotateAxisNDivFast(bufp, x, y, z, ndiv, axisp, theta)	\
{																			\
	(bufp)[0] = GXOP_MTX_MULT_4x3;											\
																			\
	(bufp) = _GXB_RotateAxis##ndiv##Fast(&(bufp)[1], axisp, theta);			\
    _GXB_TranslateBefore(bufp, x, y, z);									\
}


//----------------------------------------------------------------------
//          任意軸回転行列（三角関数による回転角指定）の適用
//
//・カレント行列に任意のベクトルを軸として回転する行列を乗算する
//  ディスプレイリストを生成します。
//・回転角度はサインとコサインにて指定します。
//
//・通常版は関数内で平方根演算器と除算器を使用しますが、高速版は使用しません
//  （高速版には単位ベクトルを渡して下さい）。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  axisp   回転軸ベクトルのポインタ
//  sinA    回転角度のサイン
//  cosA    回転角度のコサイン
//
//・戻り値：なし
//
//※通常版は平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_RotateAxisSinCos(bufp, axisp, sinA, cosA)					\
{																		\
	(bufp)[0] = GXOP_MTX_MULT_3x3;										\
																		\
	(bufp) = _GXB_RotateAxisSinCos(&(bufp)[1], axisp, sinA, cosA);		\
}
#define GXB_RotateAxisSinCosFast(bufp, axisp, sinA, cosA)				\
{																		\
	(bufp)[0] = GXOP_MTX_MULT_3x3;										\
																		\
	(bufp) = _GXB_RotateAxisSinCosFast(&(bufp)[1], axisp, sinA, cosA);	\
}

u32 *_GXB_RotateAxisSinCos(u32 *bufp, const Vec *axisp, s32 sinA, s32 cosA);
u32 *_GXB_RotateAxisSinCosFast(u32 *bufp, const Vec *axisp, s32 sinA, s32 cosA);

//----------------------------------------------------------------------
//          平行移動行列を適用後に
//          任意軸回転行列（三角関数による回転角指定）を適用
//
//・カレント行列へ平行移動行列と任意軸回転行列の結合行列を乗算する
//  ディスプレイリストを生成します。
//・回転角度はサインとコサインにて指定します。
//
//・通常版は関数内で平方根演算器と除算器を使用しますが、高速版は使用しません
//  （高速版には単位ベクトルを渡して下さい）。
//・GXB_Translate()＋GXB_RotateAxisSinCos[Fast]() よりも
//  ジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       平行移動のX成分
//  y       平行移動のY成分
//  z       平行移動のZ成分
//  axisp   回転軸ベクトルのポインタ
//  sinA    回転角度のサイン
//  cosA    回転角度のコサイン
//
//・戻り値：なし
//
//※通常版は平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Translate2RotateAxisSinCos(    bufp, x, y, z, axisp, sinA, cosA)		GXB_Translate2RotateAxisSinCosPriv(    bufp, x, y, z, axisp, sinA, cosA)
#define GXB_Translate2RotateAxisSinCosFast(bufp, x, y, z, axisp, sinA, cosA)		GXB_Translate2RotateAxisSinCosPrivFast(bufp, x, y, z, axisp, sinA, cosA)

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_Translate2RotateAxisSinCosPriv(    bufp, x, y, z, axisp, sinA, cosA)	\
		GXB_Translate2RotateAxisSinCosNDiv(    bufp, x, y, z, axisp, sinA, cosA)
#define GXB_Translate2RotateAxisSinCosNDiv(    bufp, x, y, z, axisp, sinA, cosA)	\
{																					\
	(bufp)[0] = GXOP_MTX_MULT_4x3;													\
																					\
	(bufp) = _GXB_RotateAxisSinCos(&(bufp)[1], axisp, sinA, cosA);					\
    _GXB_TranslateBefore(bufp, x, y, z);											\
}
#define GXB_Translate2RotateAxisSinCosPrivFast(bufp, x, y, z, axisp, sinA, cosA)	\
		GXB_Translate2RotateAxisSinCosNDivFast(bufp, x, y, z, axisp, sinA, cosA)
#define GXB_Translate2RotateAxisSinCosNDivFast(bufp, x, y, z, axisp, sinA, cosA)	\
{																					\
	(bufp)[0] = GXOP_MTX_MULT_4x3;													\
																					\
	(bufp) = _GXB_RotateAxisSinCosFast(&(bufp)[1], axisp, sinA, cosA);				\
    _GXB_TranslateBefore(bufp, x, y, z);											\
}


//----------------------------------------------------------------------
//          Ｚ軸にアライメントする回転行列の適用
//
//・カレント行列に任意軸をZ軸の正方向と一致させる回転を行う行列を乗算する
//  ディスプレイリストを生成します。
//
// H = sqrt (X*X + Z*Z)
//
//            [ 1            ]  [ Z/H    -X/H ]                [   Z/H      -X/H ]
// [   v   ]  [    H/1  -Y/1 ]  [      1      ]  =  [   v   ]  [ -YX/H  H  -YZ/H ]
//            [    Y/1   H/1 ]  [ X/H     Z/H ]                [   X    Y    Z   ]
//
//・関数内で平方根演算器と除算器を使用します。
//
//・引数：
//  bufp       ディスプレイリストバッファのポインタ
//  vLookInvp  視線と逆方向の単位ベクトル（*_LookAt*() で得られます）
//
//・戻り値：なし
//
//※平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_AlignZ(bufp, vLookInvp)							\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_AlignZ(&(bufp)[1], vLookInvp);			\
}

u32 *_GXB_AlignZ(u32 *bufp, const Vec *vLookInvp);

//----------------------------------------------------------------------
//          平行移動行列を適用後に
//          Ｚ軸にアライメントする回転行列を適用
//
//・カレント行列へ平行移動行列と任意軸をZ軸の正方向と一致させる回転を行う行列
//  との結合行列を乗算する、ディスプレイリストを生成します。
//
// H = sqrt (X*X + Z*Z)
//
//            [ 1            ]  [ Z/H    -X/H ]                [   Z/H      -X/H ]
// [   v   ]  [    H/1  -Y/1 ]  [      1      ]  =  [   v   ]  [ -YX/H  H  -YZ/H ]
//            [    Y/1   H/1 ]  [ X/H     Z/H ]                [   X    Y    Z   ]
//
//・関数内で平方根演算器と除算器を使用します。
//・GXB_Translate()＋GXB_AlignZ() よりもジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp       ディスプレイリストバッファのポインタ
//  x           平行移動のX成分
//  y           平行移動のY成分
//  z           平行移動のZ成分
//  vLookInvp   視線と逆方向の単位ベクトル（*_LookAt*() で得られます）
//
//・戻り値：なし
//
//※平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Translate2AlignZ(bufp, x, y, z, vLookInvp)		\
{															\
	(bufp)[0] = GXOP_MTX_MULT_4x3;							\
															\
	(bufp) = _GXB_AlignZ(&(bufp)[1], vLookInvp);			\
    _GXB_TranslateBefore(bufp, x, y, z);					\
}


//----------------------------------------------------------------------
//          クォータニオンから変換した回転行列の適用
//
//・カレント行列へクォータニオンから変換した回転行列を適用する
//  ディスプレイリストを生成します。
//
//・通常版は除算器を使用しますが、高速版は使用しません
//  （高速版には正規化クォータニオンを渡して下さい）。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  quatp   クォータニオンのポインタ
//
//・戻り値：なし
//
//※通常版は除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  ストールしてしまいます。
//----------------------------------------------------------------------

#define GXB_QuatMtx(bufp, quatp)							\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_QuatMtx(&(bufp)[1], quatp);				\
}
#define GXB_QuatMtxFast(bufp, quatp)						\
{															\
	(bufp)[0] = GXOP_MTX_MULT_3x3;							\
															\
	(bufp) = _GXB_QuatMtxFast(&(bufp)[1], quatp);			\
}

u32 *_GXB_QuatMtx(u32 *bufp, const Quat *quatp);
u32 *_GXB_QuatMtxFast(u32 *bufp, const Quat *quatp);

//----------------------------------------------------------------------
//          平行移動行列を適用後に
//          クォータニオンから変換した回転行列を適用
//
//・カレント行列へ平行移動行列とクォータニオンから変換した回転行列
//  の結合行列を乗算する、ディスプレイリストを生成します。
//
//・通常版は除算器を使用しますが、高速版は使用しません
//  （高速版には正規化クォータニオンを渡して下さい）。
//・GXB_Translate()＋GXB_QuatMtx[Fast]() よりもジオメトリエンジンの負荷を減らせます。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  quatp   クォータニオンのポインタ
//
//・戻り値：なし
//
//※通常版は除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  ストールしてしまいます。
//----------------------------------------------------------------------

#define GXB_Translate2QuatMtx(    bufp, x, y, z, quatp)			GXB_Translate2QuatMtxPriv(    bufp, x, y, z, quatp)
#define GXB_Translate2QuatMtxFast(bufp, x, y, z, quatp)			GXB_Translate2QuatMtxPrivFast(bufp, x, y, z, quatp)

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_Translate2QuatMtxPriv(    bufp, x, y, z, quatp)		\
		GXB_Translate2QuatMtxNDiv(    bufp, x, y, z, quatp)
#define GXB_Translate2QuatMtxNDiv(    bufp, x, y, z, quatp)		\
{																\
	(bufp)[0] = GXOP_MTX_MULT_4x3;								\
																\
	(bufp) = _GXB_QuatMtx(&(bufp)[1], quatp);					\
    _GXB_TranslateBefore(bufp, x, y, z);						\
}
#define GXB_Translate2QuatMtxPrivFast(bufp, x, y, z, quatp)		\
		GXB_Translate2QuatMtxNDivFast(bufp, x, y, z, quatp)
#define GXB_Translate2QuatMtxNDivFast(bufp, x, y, z, quatp)		\
{																\
	(bufp)[0] = GXOP_MTX_MULT_4x3;								\
																\
	(bufp) = _GXB_QuatMtxFast(&(bufp)[1], quatp);				\
    _GXB_TranslateBefore(bufp, x, y, z);						\
}


//----------------------------------------------------------------------
//          左右対称の透視射影行列の適用
//
//・左右対称の透視法視錐台の行列を作成し、それをカレント行列へ乗算する
//  ディスプレイリストを生成します。
//
//・関数内で除算器を使用します。
//
//・引数：
//  opp     ディスプレイリストバッファ中のコマンド領域のポインタ
//  prmp    ディスプレイリストバッファ中のパラメータ領域のポインタ
//  fovy    縦方向の視野角度［256｜1024｜4096段階］
//  aspect  横方向の視野を確定する縦横比（視界での 幅/高さ） 
//  near    視点からnearクリップ面までの距離（常に正）
//  far     視点からfarクリップ面までの距離 （常に正）
//  scaleW  クリップ座標W値のスケールパラメータ（座標変換後の精度調整）
//
//・戻り値：なし
//
//※除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Perspective(bufp, fovy, aspect, near, far, scaleW)			GXB_PerspectivePriv(SIN_NDIV_DEFAULT, bufp, fovy, aspect, near, far, scaleW)

#define GXB_Perspective256( bufp, fovy, aspect, near, far, scaleW)		GXB_PerspectivePriv(256,  bufp, fovy, aspect, near, far, scaleW)
#define GXB_Perspective1024(bufp, fovy, aspect, near, far, scaleW)		GXB_PerspectivePriv(1024, bufp, fovy, aspect, near, far, scaleW)
#define GXB_Perspective4096(bufp, fovy, aspect, near, far, scaleW)		GXB_PerspectivePriv(4096, bufp, fovy, aspect, near, far, scaleW)

u32 *_GXB_Perspective256(u32 *bufp, u32 fovy, s32 aspect, s32 near, s32 far, s32 scaleW);
u32 *_GXB_Perspective1024(u32 *bufp, u32 fovy, s32 aspect, s32 near, s32 far, s32 scaleW);
u32 *_GXB_Perspective4096(u32 *bufp, u32 fovy, s32 aspect, s32 near, s32 far, s32 scaleW);

// 中間マクロ（下記のマクロは直接使用しないで下さい）

#define GXB_PerspectivePriv(ndiv, bufp, fovy, aspect, near, far, scaleW)			\
		GXB_PerspectiveNDiv(ndiv, bufp, fovy, aspect, near, far, scaleW)
#define GXB_PerspectiveNDiv(ndiv, bufp, fovy, aspect, near, far, scaleW)			\
{																					\
	(bufp)[0] = GXOP_MTX_MULT_4x4;													\
																					\
	(bufp) = _GXB_Perspective##ndiv(&(bufp)[1], fovy, aspect, near, far, scaleW);	\
}

//----------------------------------------------------------------------
//          左右対称の透視射影行列（三角関数による視野角指定）の適用
//
//・左右対称の透視法視錐台の行列を作成し、それをカレント行列へ乗算する
//  ディスプレイリストを生成します。
//・視野角度はサインとコサインにて指定します。
//
//・関数内で除算器を使用します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  sinA    縦方向の視野角度のサイン
//  cosA    縦方向の視野角度のコサイン（上位関数からの呼び出し高速化のため最後に渡す）
//  aspect  横方向の視野を確定する縦横比（視野の 幅/高さ） 
//  near    視点からnearクリップ面までの距離（常に正）
//  far     視点からfarクリップ面までの距離 （常に正）
//  scaleW  クリップ座標W値のスケールパラメータ（座標変換後の精度調整）
//
//・戻り値：なし
//
//※除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_PerspectiveSinCos(bufp, sinA, fovy, aspect, near, far, scaleW, cosA)				\
{																								\
	(bufp)[0] = GXOP_MTX_MULT_4x4;																\
																								\
	(bufp) = _GXB_PerspectiveSinCos(&(bufp)[1], sinA, fovy, aspect, near, far, scaleW, cosA);	\
}

u32 *_GXB_PerspectiveSinCos(u32 *bufp, s32 sinA, s32 aspect, s32 near, s32 far, s32 scaleW, s32 cosA);

//----------------------------------------------------------------------
//          透視射影行列の適用
//
//・透視法視錐台の行列を作成し、それをカレント行列へ乗算する
//  ディスプレイリストを生成します。
//
//・関数内で除算器を使用します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  t       nearクリップ面上辺のy座標
//  b       nearクリップ面下辺のy座標
//  l       nearクリップ面左辺のx座標 
//  r       nearクリップ面右辺のx座標 
//  n       視点からnearクリップ面までの距離（常に正）
//  f       視点からfarクリップ面までの距離 （常に正）
//  scaleW  クリップ座標W値のスケールパラメータ（座標変換後の精度調整）
//
//・戻り値：なし
//
//※除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Frustum(bufp, t, b, l, r, n, f, scaleW)					\
{																	\
	(bufp)[0] = GXOP_MTX_MULT_4x4;									\
																	\
	(bufp) = _GXB_Frustum(&(bufp)[1], t, b, l, r, n, f, scaleW);	\
}

u32 *_GXB_Frustum(u32 *bufp, s32 t, s32 b, s32 l, s32 r, s32 n, s32 f, s32 scaleW);

//----------------------------------------------------------------------
//          正射影行列の適用
//
//・正射影の平行視体積の行列を作成し、それをカレント行列へ乗算する
//  ディスプレイリストを生成します。
//
//・関数内で除算器を使用します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  t       nearクリップ面上辺のy座標
//  b       nearクリップ面下辺のy座標
//  l       nearクリップ面左辺のx座標 
//  r       nearクリップ面右辺のx座標 
//  n       視点からnearクリップ面までの距離（正負どちらでも可）
//  f       視点からfarクリップ面までの距離 （正負どちらでも可）
//  scaleW  クリップ座標W値のスケールパラメータ（座標変換後の精度調整）
//
//・戻り値：なし
//
//※除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_Ortho(bufp, t, b, l, r, n, f, scaleW)					\
{																	\
	(bufp)[0] = GXOP_MTX_MULT_4x4;									\
																	\
	(bufp) = _GXB_Ortho(&(bufp)[1], t, b, l, r, n, f, scaleW);		\
}

u32 *_GXB_Ortho(u32 *bufp, s32 t, s32 b, s32 l, s32 r, s32 n, s32 f, s32 scaleW);

//----------------------------------------------------------------------
//          視界行列の適用
//
//・視界行列を作成し、それをカレント行列へ乗算する
//  ディスプレイリストを生成します。
//
//・関数内でベクトルの正規化のために平方根演算器と除算器を使用します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  eye     視点
//  at      注視点
//  vUp     上方向ベクトル
//  vDst    0（NULLポインタ）以外を渡すと、視線逆方向ベクトルを返します
//
//・戻り値：なし
//
//※平方根演算器と除算器を使用するため、TCM上で実行したとしても
//  ディスプレイリスト等のDMA転送とシステムバス上で衝突した場合には
//  CPUのストールが発生してしまいます。
//----------------------------------------------------------------------

#define GXB_LookAt(    bufp, eye, at, vUp, vDst)						\
{																		\
	(bufp)[0] = GXOP_MTX_MULT_4x3;										\
																		\
	(bufp) = _GXB_LookAt(&(bufp)[1], eye, at, vUp, vDst);				\
}
#define GXB_LookAtFast(bufp, eye, at, vUp, vDst)						\
{																		\
	(bufp)[0] = GXOP_MTX_MULT_4x3;										\
																		\
	(bufp) = _GXB_LookAtFast(&(bufp)[1], eye, at, vUp, vDst);			\
}

u32 *_GXB_LookAt(    u32 *bufp, const Pos *eye, const Pos *at, const Vec *vUp, Vec *vDst);
u32 *_GXB_LookAtFast(u32 *bufp, const Pos *eye, const Pos *at, const Vec *vUp, Vec *vDst);


//----------------------------------------------------------------------
//          ボックステスト
//
//・立方体が視体積に入るかどうかをテストための構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  box     テストボックス（XYZWHD161616161616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_BoxTest1(bufp, box)								\
{															\
	(bufp)[0] = GXOP_BOX_TEST;								\
	*(TestBox *)&(bufp)[1] = (box);							\
															\
	(bufp) += (1 + GXOP_BOX_TEST_NPARAMS);					\
}

//----------------------------------------------------------------------
//          ボックステスト
//
//・立方体が視体積に入るかどうかをテストために各パラメータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       テストボックス左下X座標（16bit）
//  y       テストボックス左下Y座標（ 〃  ）
//  z       テストボックス左下Z座標（ 〃  ）
//  w       テストボックス幅       （ 〃  ）
//  h       テストボックス高さ     （ 〃  ）
//  d       テストボックス奥行き   （ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_BoxTest6(bufp, x, y, z, w, h, d)				\
{															\
	(bufp)[0] = GXOP_BOX_TEST;								\
	(bufp)[1] = XY1616(x, y);								\
	(bufp)[2] = ZW1616(z, w);								\
	(bufp)[3] = HD1616(h, d);								\
															\
	(bufp) += (1 + GXOP_BOX_TEST_NPARAMS);					\
}

//----------------------------------------------------------------------
//          位置座標テスト
//
//・テスト用の位置座標の構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（XYZ161616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PositionTest1(bufp, pos)						\
{															\
	(bufp)[0] = GXOP_POS_TEST;								\
	*(Pos16 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_POS_TEST_NPARAMS);					\
}

//----------------------------------------------------------------------
//          位置座標テスト
//
//・テスト用の位置座標の各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標X成分（16bit）
//  y               Y成分（ 〃  ）
//  z               Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PositionTest3(bufp, x, y, z)					\
{															\
	(bufp)[0] = GXOP_POS_TEST;								\
	(bufp)[1] = XY1616(x, y);								\
	(bufp)[2] = (z);										\
															\
	(bufp) += (1 + GXOP_POS_TEST_NPARAMS);					\
}

//----------------------------------------------------------------------
//          方向ベクトルテスト
//
//・テスト用の方向ベクトル構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  vector  方向ベクトル（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VectorTest1(bufp, vector)						\
{															\
	(bufp)[0] = GXOP_VEC_TEST;								\
	*(Vec10 *)&(bufp)[1] = (vector);						\
															\
	(bufp) += (1 + GXOP_VEC_TEST_NPARAMS);					\
}

//----------------------------------------------------------------------
//          方向ベクトルテスト
//
//・テスト用の方向ベクトルの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       方向ベクトルX成分（10bit）
//  y                   Y成分（ 〃  ）
//  z                   Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VectorTest3(bufp, x, y, z)						\
{															\
	(bufp)[0] = GXOP_VEC_TEST;								\
	(bufp)[1] = XYZ101010(x, y, z);							\
															\
	(bufp) += (1 + GXOP_VEC_TEST_NPARAMS);					\
}


//----------------------------------------------------------------------
//          ライトベクトル設定
//
//・ライトベクトルへライトベクトル構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp        ディスプレイリストバッファのポインタ
//  lightVector ライトベクトル（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightVector1(bufp, lightVector)					\
{															\
	(bufp)[0] = GXOP_LIGHT_VECTOR;							\
	*(LightVector *)&(bufp)[1] = (lightVector);				\
															\
	(bufp) += (1 + GXOP_LIGHT_VECTOR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ライトカラー設定
//
//・ライトカラーへライトカラー構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp        ディスプレイリストバッファのポインタ
//  lightColor  ライトカラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightColor1(bufp, lightColor)					\
{															\
	(bufp)[0] = GXOP_LIGHT_COLOR;							\
	*(LightColor *)&(bufp)[1] = (lightColor);				\
															\
	(bufp) += (1 + GXOP_LIGHT_COLOR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ライトベクトル設定
//
//・ライトベクトルへライト番号と方向ベクトルを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  no      ライト番号
//  vector  方向ベクトル（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightVector2(bufp, no, vector)					\
{															\
	(bufp)[0] = GXOP_LIGHT_VECTOR;							\
	(bufp)[1] = ((no)<<LIGHT_ID_SHIFT | *(u32 *)&(vector));	\
															\
	(bufp) += (1 + GXOP_LIGHT_VECTOR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ライトカラー設定
//
//・ライトカラーへライト番号とカラーを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  no      ライト番号
//  color   カラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightColor2(bufp, no, color)					\
{															\
	(bufp)[0] = GXOP_LIGHT_COLOR;							\
	(bufp)[1] = ((no)<<LIGHT_ID_SHIFT | *(u16 *)&(color));	\
															\
	(bufp) += (1 + GXOP_LIGHT_COLOR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ライトベクトル設定
//
//・ライトベクトルへライト番号と方向ベクトルの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  no      ライト番号
//  x       方向ベクトルX成分（10bit）
//  y                   Y成分（ 〃  ）
//  z                   Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightVector4(bufp, no, x, y, z)					\
{															\
	(bufp)[0] = GXOP_LIGHT_VECTOR;							\
	(bufp)[1] = LIGHT_VECTOR(no, x, y, z);					\
															\
	(bufp) += (1 + GXOP_LIGHT_VECTOR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ライトカラー設定
//
//・ライトカラーへライト番号とカラーの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  no      ライト番号
//  r       赤成分（5bit）
//  g       緑成分（ 〃 ）
//  b       青成分（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_LightColor4(bufp, no, r, g, b)					\
{															\
	(bufp)[0] = GXOP_LIGHT_COLOR;							\
	(bufp)[1] = LIGHT_COLOR(no, r, g, b);					\
															\
	(bufp) += (1 + GXOP_LIGHT_COLOR_NPARAMS);				\
}


//----------------------------------------------------------------------
//          鏡面反射輝度テーブルの設定
//
//・8bitの128要素からなる鏡面反射輝度テーブルを設定する
//  ディスプレイリストを生成します。
//・全要素をまとめて転送する必要があります。
//・このテーブルを書き換えることによって、1シーン中に複数の
//  鏡面反射効果を持ったポリゴンを表示することができます。。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  srcp    鏡面反射輝度テーブルのポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_ShininessTable(bufp, srcp)						\
{															\
	(bufp)[0] = GXOP_SHININESS;								\
															\
	(bufp) = _GXB_ShininessTable(bufp, srcp);				\
}

u32 *_GXB_ShininessTable(u32 *bufp, void *srcp);


//----------------------------------------------------------------------
//          全マテリアルカラー設定
//
//・全マテリアルカラーと関連フラグをまとめた64bitデータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  colors  全マテリアルカラーデータ（RGB555 | 頂点カラー更新フラグ、鏡面反射輝度テーブル有効フラグ含む）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_MaterialColor1(bufp, colors)					\
{	GXB_DiffuseAmbient1(  bufp, ((u32 *)&(colors))[0]);		\
	GXB_SpecularEmission1(bufp, ((u32 *)&(colors))[1]);		\
}

//----------------------------------------------------------------------
//          全マテリアルカラー設定
//
//・各マテリアルカラーとそれらに関連したフラグを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  dif     ディフューズカラー（RGB555 | 頂点カラー更新フラグ含む）
//  amb     アンビエントカラー（RGB555）
//  spe     スペキュラカラー  （RGB555 | 鏡面反射輝度テーブル有効フラグ含む）
//  emi     エミッションカラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_MaterialColor4(bufp, dif, amb, spe, emi)		\
{	GXB_DiffuseAmbient2(  bufp, dif, amb);					\
	GXB_SpecularEmission2(bufp, spe, emi);					\
}

//----------------------------------------------------------------------
//          全マテリアルカラー設定
//
//・各マテリアルカラーの各要素と関連フラグを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  setCol  頂点カラー更新フラグ
//  tbl     鏡面反射輝度テーブル有効フラグ
//  dr      ディフューズカラー赤成分（5bit）
//  dg                        緑成分（ 〃 ）
//  db                        青成分（ 〃 ）
//  ar      アンビエントカラー赤成分（ 〃 ）
//  ag                        緑成分（ 〃 ）
//  ab                        青成分（ 〃 ）
//  sr      スペキュラカラー  赤成分（ 〃 ）
//  sg                        緑成分（ 〃 ）
//  sb                        青成分（ 〃 ）
//  er      エミッションカラー赤成分（ 〃 ）
//  eg                        緑成分（ 〃 ）
//  eb                        青成分（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_MaterialColor14(bufp, setCol, tbl, dr, dg, db, ar, ag, ab, sr, sg, sb, er, eg, eb)	\
{	GXB_DiffuseAmbient7(bufp, setCol, dr, dg, db, ar, ag, ab);	\
	GXB_SpecularEmission7(bufp, tbl, sr, sg, sb, er, eg, eb);	\
}

//----------------------------------------------------------------------
//          ディフューズ＆アンビエントカラー設定
//
//・ディフューズカラーとアンビエントカラーをまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  colors  ディフューズ＆アンビエントカラー（RGB555 | 頂点カラー更新フラグ含む）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_DiffuseAmbient1(bufp, colors)					\
{															\
	(bufp)[0] = GXOP_DIF_AMB;								\
	(bufp)[1] = (colors);									\
															\
	(bufp) += (1 + GXOP_DIF_AMB_NPARAMS);					\
}

//----------------------------------------------------------------------
//          スペキュラ＆エミッションカラー設定
//
//・スペキュラカラーとエミッションカラーをまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  colors  スペキュラ＆エミッションカラー（RGB555 | 鏡面反射輝度テーブル有効フラグ含む）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_SpecularEmission1(bufp, colors)					\
{															\
	(bufp)[0] = GXOP_SPE_EMI;								\
	(bufp)[1] = (colors);									\
															\
	(bufp) += (1 + GXOP_SPE_EMI_NPARAMS);					\
}

//----------------------------------------------------------------------
//          ディフューズ＆アンビエントカラー設定
//
//・ディフューズカラーとアンビエントカラーを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  dif     ディフューズカラー（RGB555 | 頂点カラー更新フラグ含む）
//  amb     アンビエントカラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_DiffuseAmbient2(bufp, dif, amb)					\
{															\
	(bufp)[0] = GXOP_DIF_AMB;								\
	(bufp)[1] = (*(u16 *)&(dif) | (*(u16 *)&(amb))<<16);	\
															\
	(bufp) += (1 + GXOP_DIF_AMB_NPARAMS);					\
}

//----------------------------------------------------------------------
//          スペキュラ＆エミッションカラー設定
//
//・スペキュラカラーとエミッションカラーを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  spe     スペキュラカラー  （RGB555 | 鏡面反射輝度テーブル有効フラグ含む）
//  emi     エミッションカラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_SpecularEmission2(bufp, spe, emi)				\
{															\
	(bufp)[0] = GXOP_SPE_EMI;								\
	(bufp)[1] = (*(u16 *)&(spe) | (*(u16 *)&(emi))<<16);	\
															\
	(bufp) += (1 + GXOP_SPE_EMI_NPARAMS);					\
}

//----------------------------------------------------------------------
//          ディフューズ＆アンビエントカラー設定
//
//・ディフューズカラーとアンビエントカラーの各要素と
//  頂点カラー更新フラグを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  setCol  頂点カラー更新フラグ
//  dr      ディフューズカラー赤成分（5bit）
//  dg                        緑成分（ 〃 ）
//  db                        青成分（ 〃 ）
//  ar      アンビエントカラー赤成分（ 〃 ）
//  ag                        緑成分（ 〃 ）
//  ab                        青成分（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_DiffuseAmbient7(bufp, setCol, dr, dg, db, ar, ag, ab)	\
{															\
	(bufp)[0] = GXOP_DIF_AMB;								\
	(bufp)[1] = ((setCol) | RGB555(dr, dg, db)				\
						  | RGB555(ar, ag, ab)<<16);		\
															\
	(bufp) += (1 + GXOP_DIF_AMB_NPARAMS);					\
}

//----------------------------------------------------------------------
//          スペキュラ＆エミッションカラー設定
//
//・スペキュラカラーとエミッションカラーの各要素と
//  鏡面反射輝度テーブル有効フラグを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  tbl     鏡面反射輝度テーブル有効フラグ
//  sr      スペキュラカラー  赤成分（5bit）
//  sg                        緑成分（ 〃 ）
//  sb                        青成分（ 〃 ）
//  er      エミッションカラー赤成分（ 〃 ）
//  eg                        緑成分（ 〃 ）
//  eb                        青成分（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_SpecularEmission7(bufp, tbl, sr, sg, sb, er, eg, eb)	\
{															\
	(bufp)[0] = GXOP_SPE_EMI;								\
	(bufp)[1] = ((tbl) | RGB555(sr, sg, sb)					\
					   | RGB555(er, eg, eb)<<16);			\
															\
	(bufp) += (1 + GXOP_SPE_EMI_NPARAMS);					\
}


//----------------------------------------------------------------------
//          ポリゴン属性の設定
//
//・ポリゴン属性をまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  attr    ポリゴン属性
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PolygonAttr1(bufp, attr)						\
{															\
	(bufp)[0] = GXOP_POLYGON_ATTR;							\
	(bufp)[1] = (attr);										\
															\
	(bufp) += (1 + GXOP_POLYGON_ATTR_NPARAMS);				\
}

//----------------------------------------------------------------------
//          ポリゴン属性の設定
//
//・ポリゴンのIDとアルファ値と他の属性を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  id      ID        （6bit）
//  alpha   アルファ値（5bit）
//  attr    他のポリゴン属性
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_PolygonAttr3(bufp, id, alpha, attr)				\
{															\
	(bufp)[0] = GXOP_POLYGON_ATTR;							\
	(bufp)[1] = (id)   <<POLYATTR_ID_SHIFT					\
			   | (alpha)<<POLYATTR_ALPHA_SHIFT				\
			   | (attr);									\
															\
	(bufp) += (1 + GXOP_POLYGON_ATTR_NPARAMS);				\
}


//----------------------------------------------------------------------
//          テクスチャイメージパラメータ設定（シフト調整無し）
//
//・テクスチャィメージのパラメータをまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//・テクスチャイメージベース値はシフト調整した値を渡して下さい。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  param   テクスチャイメージパラメータ（32bit）
//
//・テクスチャイメージベースはシフト調整した値を渡して下さい。
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexImageParam1(bufp, param)						\
{															\
	(bufp)[0] = GXOP_TEXIMAGE_PARAM;						\
	(bufp)[1] = (param);									\
															\
	(bufp) += (1 + GXOP_TEXIMAGE_PARAM_NPARAMS);			\
}

//----------------------------------------------------------------------
//          テクスチャイメージパラメータ設定（シフト調整有り）
//
//・テクスチャィメージのパラメータを設定する
//  ディスプレイリストを生成します。
//・テクスチャイメージベース値のシフト調整が行われますので、
//  アドレスをそのまま渡して下さい。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  basep   テクスチャイメージベースのポインタ
//  param   テクスチャイメージパラメータ（16bit）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexImageParam2(bufp, basep, param)				\
{															\
	(bufp)[0] = GXOP_TEXIMAGE_PARAM;						\
	(bufp)[1] = Addr2TexImageBase(basep) | (param);			\
															\
	(bufp) += (1 + GXOP_TEXIMAGE_PARAM_NPARAMS);			\
}

//----------------------------------------------------------------------
//          テクスチャパレットベース設定（シフト調整無し）
//
//・テクスチャパレットベースのパラメータをまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//・テクスチャパレットベース値はシフト調整した値を渡して下さい。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  base    テクスチャパレットベース
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexPlttBase1(bufp, base)						\
{															\
	(bufp)[0] = GXOP_TEXPLTT_BASE;							\
	(bufp)[1] = (u32 )(base);								\
															\
	(bufp) += (1 + GXOP_TEXPLTT_BASE_NPARAMS);				\
}

//----------------------------------------------------------------------
//          テクスチャパレットベース設定（シフト調整有り）
//
//・テクスチャパレットベースのパラメータを設定する
//  ディスプレイリストを生成します。
//・テクスチャパレットベース値のシフト調整を行いますので、
//  アドレスをそのまま渡して下さい。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  basep   テクスチャパレットベースのポインタ
//  mode    テクスチャモード
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexPlttBase2(bufp, basep, mode)					\
{															\
	(bufp)[0] = GXOP_TEXPLTT_BASE;							\
	(bufp)[1] = Addr2TexPlttBase(basep, mode);				\
															\
	(bufp) += (1 + GXOP_TEXPLTT_BASE_NPARAMS);				\
}


//----------------------------------------------------------------------
//          プリミティブの頂点リスト開始
//
//・プリミティブの頂点リストの開始を宣言する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp        ディスプレイリストバッファのポインタ
//  primType    プリミティブタイプ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Begin(bufp, primType)							\
{															\
	(bufp)[0] = GXOP_BEGIN;									\
	(bufp)[1] = (primType);									\
															\
	(bufp) += (1 + GXOP_BEGIN_NPARAMS);						\
}

//----------------------------------------------------------------------
//          プリミティブの頂点リスト終了
//
//・プリミティブの頂点リストの終了を宣言する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_End(bufp)										\
{															\
	(bufp)[0] = GXOP_END;									\
															\
	(bufp) += (1 + GXOP_END_NPARAMS);						\
}

//----------------------------------------------------------------------
//          頂点カラーの直接設定
//
//・頂点カラーを直接設定する、ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  color   カラー（RGB555）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Color1(bufp, color)								\
{															\
	(bufp)[0] = GXOP_COLOR;									\
	(bufp)[1] = *(u16 *)&(color);							\
															\
	(bufp) += (1 + GXOP_COLOR_NPARAMS);						\
}

//----------------------------------------------------------------------
//          頂点カラーの直接設定
//
//・頂点カラーの各要素を直接設定する、ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  r       赤成分（5bit）
//  g       緑成分（ 〃 ）
//  b       青成分（ 〃 ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Color3(bufp, r, g, b)							\
{															\
	(bufp)[0] = GXOP_COLOR;									\
	(bufp)[1] = RGB555(r, g, b);							\
															\
	(bufp) += (1 + GXOP_COLOR_NPARAMS);						\
}

//----------------------------------------------------------------------
//          法線ベクトル
//
//・法線ベクトルへ10bitベクトル構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  normal  方向ベクトル（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Normal1(bufp, normal)							\
{															\
	(bufp)[0] = GXOP_NORMAL;								\
	*(Vec10 *)&(bufp)[1] = (normal);						\
															\
	(bufp) += (1 + GXOP_NORMAL_NPARAMS);					\
}

//----------------------------------------------------------------------
//          法線ベクトル
//
//・法線ベクトルへ10bitベクトルフォーマットの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       方向ベクトルX成分（10bit）
//  y                   Y成分（ 〃  ）
//  z                   Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Normal3(bufp, x, y, z)							\
{															\
	(bufp)[0] = GXOP_NORMAL;								\
	(bufp)[1] = XYZ101010(x, y, z);							\
															\
	(bufp) += (1 + GXOP_NORMAL_NPARAMS);					\
}

//----------------------------------------------------------------------
//          テクスチャ座標
//
//・テクスチャ座標へテクスチャ座標構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  coord   テクスチャ座標（ST1616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexCoord1(bufp, coord)							\
{															\
	(bufp)[0] = GXOP_TEXCOORD;								\
	*(TexCoord *)&(bufp)[1] = (coord);						\
															\
	(bufp) += (1 + GXOP_TEXCOORD_NPARAMS);					\
}

//----------------------------------------------------------------------
//          テクスチャ座標
//
//・テクスチャ座標へ各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  s       テクスチャ座標S成分（16bit）
//  t                     T成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_TexCoord2(bufp, s,t)							\
{															\
	(bufp)[0] = GXOP_TEXCOORD;								\
	(bufp)[1] = ST1616(s, t);								\
															\
	(bufp) += (1 + GXOP_TEXCOORD_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標の設定と頂点の生成
//
//・頂点座標へ16bitフォーマット構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（XYZ161616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Vertex1(bufp, pos)								\
{															\
	(bufp)[0] = GXOP_VTX_16;								\
	*(Pos16 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_VTX_16_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標の設定と頂点の生成
//
//・頂点座標へ16bitフォーマットの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標X成分（16bit）
//  y               Y成分（ 〃  ）
//  z               Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_Vertex3(bufp, x, y, z)							\
{															\
	(bufp)[0] = GXOP_VTX_16;								\
	(bufp)[1] = XY1616(x, y);								\
	(bufp)[2] = (z);										\
															\
	(bufp) += (1 + GXOP_VTX_16_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標（10bit）の設定と頂点の生成
//
//・頂点座標へ10bitフォーマット構造体を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexShort1(bufp, pos)							\
{															\
	(bufp)[0] = GXOP_VTX_10;								\
	*(Pos10 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_VTX_10_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標（10bit）の設定と頂点の生成
//
//・頂点座標へ10bitフォーマットの各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標X成分（10bit）
//  y               Y成分（ 〃  ）
//  z               Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexShort3(bufp, x, y, z)						\
{															\
	(bufp)[0] = GXOP_VTX_10;								\
	(bufp)[1] = XYZ101010(x, y, z);							\
															\
	(bufp) += (1 + GXOP_VTX_10_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点XY座標の設定と頂点の生成
//
//・頂点のX座標とY座標をまとめた32bitデータを設定（Z座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（XY1616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexXY1(bufp, pos)							\
{															\
	(bufp)[0] = GXOP_VTX_XY;								\
	*(Pos2D16 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_VTX_XY_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点XY座標の設定と頂点の生成
//
//・頂点のX座標とY座標を設定（Z座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標X成分（16bit）
//  y               Y成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexXY2(bufp, x, y)							\
{															\
	(bufp)[0] = GXOP_VTX_XY;								\
	(bufp)[1] = XY1616(x, y);								\
															\
	(bufp) += (1 + GXOP_VTX_XY_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点XZ座標の設定と頂点の生成
//
//・頂点のX座標とZ座標をまとめた32bitデータを設定（Y座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（XZ1616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexXZ1(bufp, pos)							\
{															\
	(bufp)[0] = GXOP_VTX_XZ;								\
	*(Pos2D16 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_VTX_XZ_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点XZ座標の設定と頂点の生成
//
//・頂点のX座標とZ座標を設定（Y座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標X成分（16bit）
//  z               Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexXZ2(bufp, x, z)							\
{															\
	(bufp)[0] = GXOP_VTX_XZ;								\
	(bufp)[1] = XY1616(x, z);								\
															\
	(bufp) += (1 + GXOP_VTX_XZ_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点YZ座標の設定と頂点の生成
//
//・頂点のY座標とZ座標をまとめた32bitデータを設定（X座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  pos     位置座標（YZ1616）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexYZ1(bufp, pos)							\
{															\
	(bufp)[0] = GXOP_VTX_YZ;								\
	*(Pos2D16 *)&(bufp)[1] = (pos);							\
															\
	(bufp) += (1 + GXOP_VTX_YZ_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点YZ座標の設定と頂点の生成
//
//・頂点のY座標とZ座標を設定（X座標は最後の設定値を使用）する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  y       位置座標Y成分（16bit）
//  z               Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexYZ2(bufp, y, z)							\
{															\
	(bufp)[0] = GXOP_VTX_YZ;								\
	(bufp)[1] = XY1616(y, z);								\
															\
	(bufp) += (1 + GXOP_VTX_YZ_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標差分の設定と頂点の生成
//
//・頂点座標の差分値をまとめた32bitデータを設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  diff    位置座標差分（XYZ101010）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexDiff1(bufp, diff)							\
{															\
	(bufp)[0] = GXOP_VTX_DIFF;								\
	*(Pos10 *)&(bufp)[1] = (diff);							\
															\
	(bufp) += (1 + GXOP_VTX_DIFF_NPARAMS);					\
}

//----------------------------------------------------------------------
//          頂点座標差分の設定と頂点の生成
//
//・頂点座標の差分値の各要素を設定する
//  ディスプレイリストを生成します。
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  x       位置座標差分X成分（10bit）
//  y               差分Y成分（ 〃  ）
//  z               差分Z成分（ 〃  ）
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_VertexDiff3(bufp, x, y, z)						\
{															\
	(bufp)[0] = GXOP_VTX_DIFF;								\
	(bufp)[1] = XYZ101010(x, y, z);							\
															\
	(bufp) += (1 + GXOP_VTX_DIFF_NPARAMS);					\
}


//----------------------------------------------------------------------
//          レンダリングエンジン参照データ群のスワップ
//
//・このコマンドを発行した直後のVブランク期間開始時に、
//  ポリゴンリストRAM、頂点RAM、レンダリング関連レジスタ等、
//  レンダリングエンジンが参照するデータを切り替える
//  ディスプレイリストを生成します。
//・書き込んだグラフィックスデータが描画へ反映されるのは
//  このコマンドを発行した次のフレームになります
//
//・引数：
//  bufp    ディスプレイリストバッファのポインタ
//  flags   フラグ
//
//・戻り値：なし
//----------------------------------------------------------------------

#define GXB_SwapBuffers(bufp, flags)						\
{															\
	(bufp)[0] = GXOP_SWAP_BUFFERS;							\
	(bufp)[1] = (flags);									\
															\
	(bufp) += (1 + GXOP_SWAP_BUFFERS_NPARAMS);				\
}


#ifdef __cplusplus
}       // extern "C"
#endif

#endif  // _IRIS_GXB_H