上位レベル シェーダ言語

上位レベル シェーダ言語

シェーダをアセンブリ言語で記述するのが大変なときは、上位レベル シェーダ言語 (HLSL: High Level Shader Language) を使ってみるとよい。Microsoft® DirectX® 9.0 には上位レベル シェーダ言語の最初のリリースが含まれており、C に似た高級言語でシェーダを開発およびデバッグできる。この機能は、DirectX 8.0 から装備された頂点シェーダ、ピクセル シェーダ、エフェクトの作成に使うシェーダのアセンブリ言語のシェーダ機能とは別の追加機能である。

上位レベル シェーダ言語では、C に似た関数からのシェーダ開発をサポートしている。この言語は、関数、式、文、標準データ型、ユーザー定義データ型、プリプロセッサ ディレクティブなど、多くの標準的な言語機能を今後サポートする。

データ型

スカラー型

boolTRUE または FALSE
int32 ビット符号付き整数
half16 ビット浮動小数点数値
float32 ビット浮動小数点数値
double64 ビット浮動小数点数値

すべてのターゲット プラットフォームが整数値をネイティブでサポートしているわけではない。整数値は、浮動小数点数用ハードウェアを使ってエミュレートすることが必要な場合がある。このようなプラットフォーム上で、整数の範囲を超えて浮動小数点数として表される可能性のある整数演算は、予測どおりに動作するという保証はない。

すべてのターゲット プラットフォームが half 値または double 値をネイティブでサポートしているわけではない。ターゲット プラットフォームがサポートしていない場合、これらの値は浮動小数点数 (float) を使ってエミュレートされる。浮動小数点数式の中間結果は、オペランドや結果よりも高精度で評価される。

ベクトル型

vector4D のベクトル。各成分は、float 型。
vector < type, size >ディメンジョンが size のベクトル。各成分の type はスカラー型。

ベクトルの各成分には、配列アクセス構文を使って、インデックスによってアクセスできる。次に例を示す。

vec[0]		(vec.x と同じ)
vec[3]		(vec.w と同じ)

ベクトルの各成分には、構造体メンバ アクセス構文を使って、名前によってアクセスできる。ベクトルに対して次の成分名のセットが定義されている。

Default set
 x	 y	 z	 w
Color set
 r	 g	 b	 a

ベクトルの入れ換え成分を含むベクトルは、複数の成分名を連結することで形成できる。たとえば、yyzw や bgr などである。連結する名前はすべて、同じ名前セットの名前を指定すること。同じ成分は複数回繰り返し指定できるが、その場合、入れ換えは割り当てのターゲットとしては無効である。

行列型

matrix4 行 4 列の行列。各成分は float 型。
matrix < type, rows, columns >rows 行 columns 列の行列。各成分の type はスカラー型。

行列の各列ベクトルには、配列アクセス構文を使って、インデックスによってアクセスできる。次に例を示す。

mat[2]     (mat.m20m21m22m23 と同じ)
mat[2].w   (as mat.m23 と同じ)
mat[2][3]  (as mat.m23 と同じ)

行列の個々の成分には、構造体メンバ アクセス構文を使って、名前によってアクセスできる。行列に対して次の成分名のセットが定義されている。

1 から始まるセット

_11	_12	_13	_14
_21	_22	_23	_24
_31	_32	_33	_34
_41	_42	_43	_44

0 から始まるセット

_m00	_m01	_m02	_m03
_m10	_m11	_m12	_m13
_m20	_m21	_m22	_m23
_m30	_m31	_m32	_m33

行列の各成分を持つベクトルは、複数の成分名を連結すれば作成できる。たとえば、_41_42_43 や _m01_m02_m03_m04 である。連結する名前はすべて、同じ名前セットの名前を指定すること。同じ成分は複数回繰り返し指定できるが、その場合、入れ換えは割り当てのターゲットとしては無効である。

オブジェクト型

string

ASCII 文字列型。文字列を受け付ける演算やステートはない。ただし、文字列引数とコメントは、アプリケーションから ID3DXEffect インターフェイスを使って問い合わせることができる。

pixelshader

ピクセル シェーダ (pixelshader) オブジェクトは、Microsoft Direct3D® ピクセル シェーダ オブジェクトを表す。シェーダ関数内の演算で、ピクセル シェーダを直接受け付ける演算はないが、テクニック内からピクセル シェーダにデバイスを設定できる。次の属性は、構造体メンバ アクセス構文を使って、ピクセル シェーダ オブジェクトから問い合わせることができる。

const string version;

リテラル ピクセル シェーダ値は、アセンブリ ブロックとして表現できる。

pixelshader ps = asm { ps.2.0 mov oC0, c0 };			

または、次のようにコンパイル呼び出しとしての表現も可能である。

pixelshader ps = compile ps_2_0 psmain();	

sampler

サンプラ (sampler) オブジェクトは、Direct3D サンプラ ステージを表す。サンプラ ステージを使って、テクスチャをサンプリングする。サンプラには、テクスチャ タイプおよびフィルタリング タイプが割り当てられる。

sampler s = sampler_state { texture = NULL; mipfilter = LINEAR; };

texture

テクスチャ (texture) オブジェクトは、Direct3D テクスチャ オブジェクトを表す。シェーダ関数内の演算で、テクスチャを直接受け付ける演算はないが、テクニック内からテクスチャにデバイスを設定できる。次の属性は、構造体メンバ アクセス構文を使って、テクスチャ オブジェクトから問い合わせることができる。

const string type;	const string format;
const int width;
const int height;
const int depth;			

vertexshader

頂点シェーダ (vertexshader) オブジェクトは、Direct3D 頂点シェーダ オブジェクトを表す。シェーダ関数内の演算で、頂点シェーダを直接受け付ける演算はないが、テクニック内から頂点シェーダにデバイスを設定できる。次の属性は、構造体メンバ アクセス構文を使って、頂点シェーダ オブジェクトから問い合わせることができる。

const string version;

リテラル頂点シェーダ値は、アセンブリ ブロックとして表現できる。

vertexshader vs = asm { vs.2.0 mov oPos, c0 };			

または、次のようにコンパイル呼び出しとしての表現も可能である。

vertexshader vs = compile vs_2_0 psmain();	

オブジェクトの属性の構造体メンバ アクセスはまだ実装されていない。

構造体型

構造体型を定義するには、キーワード struct を使う。定義した構造体は、その 識別子 (ID) を使って参照できる。

	struct [id] { member_list }

member_list は 1 つ以上のメンバ宣言から成る。メンバ宣言は、変数宣言 (下記) に似ている。ただし、初期設定子を指定できず、static、extern、volatile、const を個別に宣言できない。

ユーザー定義型

型の名前を宣言するには、キーワード typedef を使う。型が定数であることを明示するには、キーワード const を使う。各 ID (または "id") の後に配列のサフィックスを指定できる。宣言した型は、その ID を使って参照できる。

	typedef [const] type id [array_suffix] [, id ...] ;

array_suffix はディメンジョンを表す 1 つ以上の [ literal_integer_expression ] から成る。

Direct3D エクステンション (D3DX) 8.0 エフェクトとの互換性を保つために、次の型は自動的に、スーパー グローバル スコープで大文字小文字が区別されない形で定義される。

	typedef int DWORD;
	typedef float FLOAT; 
	typedef vector<float, 4> VECTOR;
	typedef matrix<float, 4, 4> MATRIX;
	typedef string STRING;
	typedef texture TEXTURE;
	typedef pixelshader PIXELSHADER;
	typedef vertexshader VERTEXSHADER;

便宜上、次の型は自動的にスーパー グローバル スコープで定義される(これらの定義では、シャープ記号は 1 ~ 4 の数字を表す)。

	typedef vector<bool, #gt; bool#;
	typedef vector<int, #gt; int#;
	typedef vector<half, #gt; half#;
	typedef vector<float, #gt; float#;
	typedef vector<double, #gt; double#;

	typedef matrix<bool, #, #gt; bool#x#;
	typedef matrix<int, #, #gt; int#x#;
	typedef matrix<half, #, #gt; half#x#;
	typedef matrix<float, #, #gt; float#x#;
	typedef matrix<double, #, #gt; double#x#;

型変換

スカラーからスカラー常に有効。ブール型から整数型または浮動小数点数型にキャストする場合、FALSE は 0 と見なされ、TRUE は 1 と見なされる。整数型または浮動小数点数型からブール型にキャストする場合、値 0 は FALSE と見なされ、0 以外の値は TRUE と見なされる。浮動小数点数型から整数型にキャストする場合、値は 0 に向けて丸められる。
スカラーからベクトル常に有効。このキャストは、スカラーを複製してベクトルに設定するという動作をする。
スカラーから行列常に有効。このキャストは、スカラーを複製して行列に設定するという動作をする。
スカラーからオブジェクト常に無効。
スカラーから構造体構造体のすべての要素が数値の場合に限り、有効。このキャストは、スカラーを複製して構造体に設定するという動作をする。
ベクトルからスカラー常に有効。このキャストは、ベクトルの最初の成分を選択する。
ベクトルからベクトル出力ベクトルは、入力ベクトルよりも大きくならないこと。このキャストは、最左端の値を残して、残りを切り捨てるという動作をする。このキャストでは、列行列、行行列、数値の構造体はベクトルとして処理される。
ベクトルから行列ベクトルのサイズは、行列のサイズと等しくなければならない。
ベクトルからオブジェクト常に無効。
ベクトルから構造体構造体がベクトルよりも大きくなく、構造体のすべての成分が数値である限り、有効。
行列からスカラー常に有効。このキャストは、行列の左上にある成分を選択する。
行列からベクトル行列のサイズは、ベクトルのサイズと等しくなければならない。
行列から行列出力行列は、どちらのディメンジョンでも入力行列より大きくならないこと。このキャストは、左上の値を残して、残りを切り捨てるという動作をする。
行列からオブジェクト常に無効。
行列から構造体構造体のサイズは行列のサイズと等しく、構造体のすべての成分が数値でなければならない。
オブジェクトからスカラー常に無効。
オブジェクトからベクトル常に無効。
オブジェクトから行列常に無効。
オブジェクトからオブジェクトオブジェクト型が一致する場合に限り、有効。
オブジェクトから構造体構造体には、2 個以上のメンバが格納されていてはならない。そのメンバの型は、オブジェクトの型と一致しなければならない。
構造体からスカラー構造体には、少なくとも 1 つのメンバが格納されている必要がある。このメンバは、数値でなければならない。
構造体からベクトル構造体は、少なくともベクトルのサイズでなければならない。最初の成分は数値で、最大でベクトルのサイズまででなければならない。
構造体から行列構造体は、少なくとも行列のサイズでなければならない。最初の成分は数値で、最大で行列のサイズまででなければならない。
構造体からオブジェクト構造体には、少なくとも 1 つのメンバが格納されている必要がある。このメンバの型は、オブジェクトの型と一致しなければならない。
構造体から構造体出力構造体は、入力構造体よりも大きくならないこと。個々のすべての入力成分と出力成分の間で、有効なキャストが存在しなければならない。

変数

変数は次のように宣言する。


[static uniform extern shared volatile] [const] 
type id [array_suffix] [: semantic] [= initializers] [annotations] [, id ...] ;

変数宣言では、キーワード static をプレフィクスに使える。グローバル変数では、これは変数をシェーダ内部のみで使い、外部に公開しないことを示す。ローカル変数では、これは変数の値が呼び出しごとに無効にならないことを示す。static のローカル変数は、1 回だけ初期化される。明示的に初期化しない場合、初期値は 0 と見なされる。

グローバル変数の宣言では、キーワード uniform をプレフィクスに使って、その変数がシェーダへの一様な入力であることを明示できる。デフォルトでは、static でないグローバル変数は uniform である。

グローバル変数の宣言では、キーワード extern をプレフィクスに使って、その変数がシェーダへの外部入力であることを明示できる。デフォルトでは、static でないグローバル変数は extern である。

グローバル変数の宣言では、キーワード shared をプレフィクスに使える。これは、このパラメータの値の目的は、エフェクト オブジェクト間で共有することだという、エフェクト フレームワークに対するヒントである。

グローバル変数の宣言では、キーワード volatile をプレフィクスに使える。これは、このパラメータの値が頻繁に変わるという、エフェクト フレームワークに対するヒントである。

initializers は式または {式 [, 式 [, ...]]} である。extern のグローバル変数では、これらの式はリテラルである。他のグローバル変数および static のローカル変数では、これらの式は定数である。

変数にはセマンティクスを与えることができる。セマンティクスには言語上の意味はない。変数に関連付けられて、バックエンドに渡されるだけである。大文字小文字は区別されない。有効なセマンティクスとそれらの意味は、定義している関数の種類によって異なる(頂点シェーダでは、バックエンドはセマンティクスを使って入力をマップし、出力レジスタを割り当てる。シェーダの入力および出力セマンティクスの一覧は、このドキュメントの後で示す)。

グローバル変数には、コメントを付けることができる。コメントは { member_list } という形式をとる。ここで、member_list はメンバ宣言の一覧を表し、各メンバはリテラル値に初期化される。コメントは、引数に関するメタデータをエフェクトに通知するメソッドにすぎない。プログラムの中からは参照できない。コメント メンバはセマンティクスを持つことができない。

成分へのアクセスと入れ換え

基本型の各 float 成分には、次の名前表に示す添字を使って、構造体メンバへのアクセスと似た方法でアクセスできる。

_11, x, r_12, y, g_13, z, b_14, w, a
_21_22_23_24
_31_32_33_34
_41_42_43_44

これらの名前を 2 ~ 4 個連結した添字を使って、特定の成分 (入れ換え) を含むベクトルを指定できる。有効な例を次に示す。


bgr, yyzw, _12_22_32_42

すべて同じ添字セット (xyzw、rgba、または _11 ~ _44) の名前を指定すること。異なるセットは混在できない。同じ成分を繰り返し指定できる。ただし、成分を繰り返し指定する場合、入れ換えは割り当てのターゲットとしては無効である。

文と式

文は、処理の流れを制御するために使う。サポートされる文の種類を次に示す。


{ [statements] }
[expression] ;
return [expression] ;
if ( expression ) statement [else statement]
for ( [expression | variable_declaration] ; [expression] ; [expression] ) statement
do statement while ( expression ) ;
while ( expression ) statement ;

for、do、while 文はまだ実装されていない。

式は、リテラル、変数、またはリテラルと変数を「補遺」の演算子優先順位表にある演算子で結合したものである。

演算子使用方法意味結合法則
()(value)部分式左から右
()id(arguments)関数の呼び出し左から右
type(arguments)型コンストラクタ左から右
[]array[int]配列の添字左から右
.structure.idメンバの選択左から右
value.swizzle成分の入れ換え左から右
++variable++後置インクリメント (成分ごと)左から右
--variable--後置デクリメント (成分ごと)左から右
++++variable前置インクリメント (成分ごと)右から左
----variable前置デクリメント (成分ごと)右から左
!!value論理 NOT (成分ごと)右から左
--value単項マイナス (成分ごと)右から左
++value単項プラス (成分ごと)右から左
()(type) value型変換右から左
*value*value乗算 (成分ごと)左から右
/value/value除算 (成分ごと)左から右
%value%value剰余 (成分ごと)左から右
+value+value加算 (成分ごと)左から右
-value-value減算 (成分ごと)左から右
<value < value比較 : より小さい (成分ごと)左から右
>value > value比較 : より大きい (成分ごと)左から右
<=value <= value比較 : 以下 (成分ごと)左から右
>=value >= value比較 : 以上 (成分ごと)左から右
==value == value比較 : 等しい (成分ごと)左から右
!=value != value比較 : 等しくない (成分ごと)左から右
&&value && value論理 AND (成分ごと)左から右
||value||value論理 OR (成分ごと)左から右
?:float?value:value条件右から左
=variable=value代入 (成分ごと)右から左
*=variable*=value乗算代入 (成分ごと)右から左
/=variable/=value除算代入 (成分ごと)右から左
%=variable%=value剰余代入 (成分ごと)右から左
+=variable+=value加算代入 (成分ごと)右から左
-=variable-=value減算代入 (成分ごと)右から左
,value,valueコンマ左から右

C とは異なり、&&、||、?: 式の短絡評価は、決して評価を短絡しない。なぜなら、それらの式がベクトル演算で、式のすべての項が常に評価されるからである。

% 演算子は、両辺とも正か、両辺とも負の場合に限り、定義される。C とは異なり、整数型以外に、浮動小数点数のデータ型も処理する。

多くの演算子には "成分ごと" というマークが付いている。これは、入力の成分ごとに、(他の成分に対する演算とは別個に) 何らかの演算が行われ、出力ベクトルの対応する成分に結果が格納されることを意味する。

比較演算子および 2 項演算子も、成分ごとに作用する。つまり、2 つのベクトルを比較した場合、結果は、各成分を比較したブール値の結果が格納されたベクトルとなる。

2 項演算子の式では、演算が実行される前に、各辺のサイズと成分の型は両辺が同じになるよう自動的に昇格される。昇格された型によって、演算を実行する解像度と演算結果の型が決まる。たとえば、(int3 + float) 式の場合、(float3 + float3) に昇格してから評価され、その結果は float3 型となる。

関数

ユーザー定義関数

関数は C 関数と非常に似た方法で定義される。


[static inline target] [const] type id ( [parameter_list] ) ;
[static inline target] [const] type id ( [parameter_list] ) { [statements] } ;

target は、関数が作成されたプラットフォームを示す、オプションの識別子を表す。parameter_list は、1 つ以上のパラメータ宣言をコンマで区切って並べたものである。


[uniform in out inout] type id [: semantic] [= default]

パラメータの値は常に、値で渡される。in パラメータを使うと、関数の実行前に引数の値を呼び出し元からコピーする必要があることを示す。out パラメータを使うと、パラメータの最後の値をコピーして、関数が返るときにその値が呼び出し元に返される必要があることを示す。inout パラメータは、in と out の両方を指定することを略しただけである。uniform パラメータを使うと、特殊な in で、パラメータの値を定数データからとることを最上位関数に示している。最上位以外の関数にとって、uniform は、in と同義である。パラメータの使用方法を指定しない場合、パラメータの使用方法は in と見なされる。

本体のない関数を定義すると、プロトタイプと見なされる。この関数は、後のコードで本体を付けて再定義する必要がある。本体が定義されていない関数を参照すると、エラーになる。

関数は、多重定義できる。関数は、その名前、引数の型、ターゲット プラットフォーム (指定されている場合) によって一意に識別される。関数の多重定義は、まだ実装されていない。

現時点では、すべての関数がインラインである。再帰はサポートされていない。

組み込み関数

absvalue abs(value a)絶対値 (成分ごと)。
acosacos(x)x の各成分の逆余弦を返す。各成分は、[-1, 1] の範囲にする。
allall(x)x のすべての成分が 0 以外の値かどうかをテストする。
anyany(x)x のいずれかの成分が 0 以外の値かどうかをテストする。
asinasin(x)x の各成分の逆正弦を返す。各成分は、[-pi/2, pi/2] の範囲にする。
atanatan(x)x の各成分の逆正接を返す。戻り値は、[-pi/2, pi/2] の範囲である。
atan2atan2(y, x)y/x の逆正接を返す。y と x の符号を使って [-pi, pi] の範囲にある戻り値の象限を判断する。atan2 は、x が 0 と等しく、y が 0 と等しくない場合でも、原点以外の各点に対して十分に定義されている。
ceilceil(x)x 以上の最小の整数を返す。
clampclamp(x, min, max)x を [min, max] の範囲に制限する。
clipclip(x)x のいずれかの成分が 0 より小さい場合、現在のピクセルを破棄する。x の各成分が面からの距離を表す場合、この関数を使って、クリップ面をシミュレーションする。
coscos(x)x の余弦を返す。
coshcosh(x)x の双曲余弦を返す。
crosscross(a, b)2 つの 3D ベクトル a と b の外積を返す。
D3DCOLORtoUBYTE4D3DCOLORtoUBYTE4(x)4D ベクトル x の成分を入れ換えおよびスケーリングして、一部ハードウェアにある UBYTE4 サポートの不足を補正する。
ddxddx(x)スクリーン空間の x 座標について、x の偏微分を返す。
ddyddy(x)スクリーン空間の y 座標について、x の偏微分を返す。
degreesdegrees(x)x をラジアン単位から度数に変換する。
determinantdeterminant(m)正方行列 m の行列式を返す。
distancedistance(a, b)2 つの点 a と b 間の距離を返す。
dotdot(a, b)2 つのベクトル a と b の内積を返す。
expexp(x)e を底とする指数 ex を返す。
exp2value exp2(value a)2 を底とする指数 (成分ごと)。
faceforwardfaceforward(n, i, ng)-n * sign(dot(i, ng)) を返す。
floorfloor(x)x 以下の最大の整数を返す。
fmodfmod(a, b)a = i * b + f となるような、a / b の浮動小数点数の剰余 f を返す。ここで、i は整数、f は x と符号が同じで、その絶対値は b の絶対値よりも小さい。
fracfrac(x)f が 0 より大きく、1 より小さい値となるような、x の小数部 f を返す。
frcvalue frc(value a)小数部 (成分ごと)。
frexpfrexp(x, out exp)x の仮数と指数を返す。frexp は仮数を返し、指数は出力引数 exp に格納される。x が 0 の場合、関数は仮数と指数の両方に 0 を返す。
fwidthfwidth(x)abs(ddx(x))+abs(ddy(x)) を返す。
isfiniteisfinite(x)x が有限の場合は TRUE を返す。それ以外の場合は FALSE を返す。
isinfisinf(x)x が +INF か -INF の場合は TRUE を返す。それ以外の場合は FALSE を返す。
isnanisnan(x)x が NAN か QNAN の場合は TRUE を返す。それ以外の場合は FALSE を返す。
ldexpldexp(x, exp)x * 2exp を返す。
lenfloat len(value a)ベクトルの長さ。
lengthlength(v)ベクトル v の長さを返す。
lerplerp(a, b, s)a + s(b - a) を返す。この関数は、s が 0 の場合は a を返し、1 の場合は b を返すよう、a と b の間を線形補間する。
litlit(ndotl, ndoth, m)ライティングのベクトル (アンビエント、ディフューズ、スペキュラ、1) を返す。アンビエント = 1; ディフューズ = (ndotl < 0) ?0 : ndotl; スペキュラ = (ndotl < 0) || (ndoth < 0) ?0 : (ndoth * m);
loglog(x)x の、底が e の自然対数を返す。x が負の場合、この関数は無限を返す。x が 0 の場合、+INF を返す。
log10log10(x)x の、底が 10 の自然対数を返す。x が負の場合、この関数は無限を返す。x が 0 の場合、+INF を返す。
log2log2(x)x の、底が 2 の自然対数を返す。x が負の場合、この関数は無限を返す。x が 0 の場合、+INF を返す。
maxmax(a, b)a と b の大きい方を選択する。
minmin(a, b)a と b の小さい方を選択する。
modfmodf(x, out ip)値 x を、それぞれが x と同じ符号を持った小数部と整数部に分ける。x の符号付き小数部が返される。整数部は出力引数 ip に格納される。
mulmul(a, b)a と b の間の行列乗算を実行する。a がベクトルの場合、行ベクトルとして処理する。b がベクトルの場合、列ベクトルとして処理する。内部ディメンジョンの a 列 と b 行 は等しくなければならない。a 行 x b 列のディメンジョンが得られる。
noisenoise(x)実装されていない。
normalizenormalize(v)正規化されたベクトル v / length(v) を返す。v の長さが 0 の場合、結果は無限となる。
powpow(x, y)xy を返す。
radiansradians(x)x を度数からラジアン単位に変換する。
reflectreflect(i, n)入射方向 i、サーフェイス法線 n とした場合の、v = i - 2 * dot(i, n) * n によって求められる、反射ベクトル v を返す。
refractrefract(i, n, eta)入射方向 i、サーフェイス法線 n、屈折 eta の相対インデックスが与えられた場合の、屈折ベクトル v を返す。i と n の間の入射角が指定された eta よりも大きすぎると、(0,0,0) を返す。
roundround(x)x を最も近い整数に丸める。
rsqrtrsqrt(x)1 / sqrt(x) を返す。
saturatesaturate(x)x を [0, 1] の範囲に制限する。
signsign(x)x の符号を求める。x が 0 よりも小さい場合は -1、0 と等しい場合は 0、0 よりも大きい場合は 1 を返す。
sinsin(x)x の正弦を返す。
sincossincos(x, out s, out c)x の正弦と余弦を返す。sin(x) は出力引数 s に格納され、cos(x) は出力引数 c に格納される。
sinhsinh(x)x の双曲正弦を返す。
smoothstepsmoothstep(min, max, x)x < min の場合は 0 を返す。x > max の場合は 1 を返す。x が [min, max] の範囲内であれば、0 と 1 の間の滑らかなエルミート補間を返す。
sqrtvalue sqrt(value a)平方根 (成分ごと)。
stepstep(a, x)(x >= a) ? 1 : 0 を返す。
tantan(x) x の正接を返す。
tanhtanh(x)x の双曲正接を返す。
tex1Dtex1D(s, t)1D のテクスチャ参照。s はサンプラまたは sampler1D オブジェクト。t はスカラー。
tex1Dtex1D(s, t, ddx, ddy)微分を指定した、1D のテクスチャ参照。s はサンプラまたは sampler1D オブジェクト。t、ddx、ddy はスカラー。
tex1Dprojtex1Dproj(s, t)1D の射影テクスチャ参照。s はサンプラまたは sampler1D オブジェクト。t は 4D ベクトル。t は、参照が実行される直前の成分で除算される。
tex1Dbiastex1Dbias(s, t)1D のバイアス テクスチャ参照。s はサンプラまたは sampler1D オブジェクト。t は 4D ベクトル。参照を実行する前に、ミップ レベルに t.w のバイアスがかけられる。
tex2Dtex2D(s, t)2D のテクスチャ参照。s はサンプラまたは sampler2D オブジェクト。t は 2D テクスチャ座標。
tex2Dtex2D(s, t, ddx, ddy)微分を指定した、2D のテクスチャ参照。s はサンプラまたは sampler2D オブジェクト。t、ddx、ddy は 2D ベクトル。
tex2Dprojtex2Dproj(s, t)2D の射影テクスチャ参照。s はサンプラまたは sampler2D オブジェクト。t は 4D ベクトル。t は、参照が実行される直前の成分で除算される。
tex2Dbiastex2Dbias(s, t)2D のバイアス テクスチャ参照。s はサンプラまたは sampler2D オブジェクト。t は 4D ベクトル。参照を実行する前に、ミップ レベルに t.w のバイアスがかけられる。
tex3Dtex3D(s, t)3D のボリューム テクスチャ参照。s はサンプラまたは sampler3D オブジェクト。t は 3D テクスチャ座標。
tex3Dtex3D(s, t, ddx, ddy)微分を指定した、3D のボリューム テクスチャ参照。s はサンプラまたは sampler3D オブジェクト。t、ddx、ddy は 3D ベクトル。
tex3Dprojtex3Dproj(s, t)3D の射影ボリューム テクスチャ参照。s はサンプラまたは sampler3D オブジェクト。t は 4D ベクトル。t は、参照が実行される直前の成分で除算される。
tex3Dbiastex3Dbias(s, t)3D のバイアス テクスチャ参照。s はサンプラまたは sampler3D オブジェクト。t は 4D ベクトル。参照を実行する前に、ミップ レベルに t.w のバイアスがかけられる。
texCUBEtexCUBE(s, t)3D のキューブ テクスチャ参照。s はサンプラまたは samplerCUBE オブジェクト。t は 3D テクスチャ座標。
texCUBEtexCUBE(s, t, ddx, ddy)微分を指定した、3D のキューブ テクスチャ参照。s はサンプラまたは samplerCUBE オブジェクト。t、ddx、ddy は 3D ベクトル。
texCUBEprojtexCUBEproj(s, t)3D 射影のキューブ テクスチャ参照。s はサンプラまたは samplerCUBE オブジェクト。t は 4D ベクトル。t は、参照が実行される直前の成分で除算される。
transposetranspose(m)行列 m の転置行列を返す。入力のディメンジョンが m 行 x m 列の場合、結果はディメンジョン m 列 x m 行となる。

シェーダ セマンティクス

頂点シェーダ入力セマンティクス

入力セマンティクスは、頂点シェーダ入力データの使用方法を識別するコメントである。これは、固定機能パイプラインの D3DDECLUSAGE 引数に似ている。

POSITION[n]位置座標
BLENDWEIGHT[n]ブレンディングの重み
BLENDINDICES[n]ブレンドのインデックス
NORMAL[n]法線ベクトル
PSIZE[n]ポイント サイズ
DIFFUSE[n]ディフューズ色
SPECULAR[n]スペキュラ色
TEXCOORD[n]テクスチャ座標
TANGENT[n]接線
BINORMAL[n]従法線
TESSFACTOR[n]テセレーション係数

n はオプションの整数である。例 : PSIZE0、DIFFUSE1。

頂点シェーダ出力セマンティクス

出力セマンティクスは、頂点シェーダ出力データの使用方法を識別するコメントである。これは、固定機能パイプラインの D3DDECLUSAGE 引数に似ている。

POSITION位置座標
PSIZEポイント サイズ
FOG頂点フォグ
COLOR[n]色 (例 :COLOR0)
TEXCOORD[n]テクスチャ座標 (例 :TEXCOORD0)

n はオプションの整数である。例 : texcoord0。

ピクセル シェーダ入力セマンティクス

入力セマンティクスは、ピクセル シェーダ入力データの使用方法を識別するコメントである。これは、固定機能パイプラインの D3DDECLUSAGE 引数に似ている。

COLOR[n]スペキュラ色のディフューズ (例 :COLOR0 または COLOR1)
TEXCOORD[n]テクスチャ座標 (例 :TEXCOORD0)

n はオプションの整数である。例 : TEXCOORD0、TEXCOORD1。

ピクセル シェーダ出力セマンティクス

出力セマンティクスは、ピクセル シェーダ出力データの使用方法を識別するコメントである。

COLOR[n]色 (例 :COLOR0)
TEXCOORD[n]テクスチャ座標 (例 :TEXCOORD0)

n はオプションの整数である。例 : texcoord0。

グローの例

グローの適用」を参照すること。

インデックス付きのブレンドされたキャラクタ スキニング

//----------------------------------------------------------------------------
// Global parameters 
//----------------------------------------------------------------------------

texture tDiffuse;
texture tNormal;
 
float4 cAmbient  = { 0.3f, 0.3f, 0.3f, 1.0f };  // ambient color
float4 cDiffuse  = { 1.0f, 1.0f, 1.0f, 1.0f };  // diffuse color
float4 cSpecular = { 0.6f, 0.6f, 0.6f, 1.0f };  // specular color

float3 vDiffuse  = { 0.0f, 1.0f, 0.0f };        // diffuse direction
float3 vSpecular = { 0.0f, 0.0f, 0.0f };        // specular direction

struct VS_INPUT
{
    float4 vPosition        : POSITION;
    float3 vBlendWeights    : BLENDWEIGHT;
    float4 vBlendIndices    : BLENDINDICES;
    float3 vNormal          : NORMAL;
    float2 vTexCoords       : TEXCOORD0;
    float3 vTangent         : TANGENT;
    float  fFlip            : TEXCOORD1;
    float  fDisplacement    : TEXCOORD2;   
};

struct VS_OUTPUT
{
    float4 vPosition        : POSITION;
    float4 vTexCoord0       : TEXCOORD0;
    float4 vTexCoord1       : TEXCOORD1;
    float3 vDiffuse         : COLOR0;
    float3 vSpecular        : COLOR1;
};

struct PS_OUTPUT
{
    float4 vColor           : COLOR0;
};


//----------------------------------------------------------------------------
// Shader body 
//----------------------------------------------------------------------------

VS_OUTPUT main(const VS_INPUT v)
{
    VS_OUTPUT o = (VS_OUTPUT) 0;


    // Compute last blend weight.
    // An application supplies one fewer bone weights than 
    //   the number of bones. So, the last bone weight is 
    //   calculated using a dot product.

    float fLastBlendWeight = 1 - dot(v.vBlendWeights, 1);

    // The dot product is a convenient way of subtracting 
    //   the other three weights from 1.



    // Skin position(to world space)    
    // Each vertex is influenced by four bones. Each bone 
    //   must be transformed to world space, and then the result 
    //   is combined using the bone weight.
 
    float3 vPosition = 
        mul(v.vPosition, mWorld[v.vBlendIndices.x]) * v.vBlendWeights.x +
        mul(v.vPosition, mWorld[v.vBlendIndices.y]) * v.vBlendWeights.y +
        mul(v.vPosition, mWorld[v.vBlendIndices.z]) * v.vBlendWeights.z +
        mul(v.vPosition, mWorld[v.vBlendIndices.w]) * fLastBlendWeight;



    // Each normal is also influenced by four bones. Because normals 
    //   cannot be transformed using the world matrix (because they 
    //   end up with orientation problems if x,y,z scaling is not 
    //   uniform), normals need to be transformed using an 
    //   inverse-transpose matrix (mNormal). Otherwise, the mathematics 
    //   is nearly the same (the data types are different) as the 
    //   vertex position computation.

    // Skin normal (to world space)
    float3 vNormal =
        mul(v.vNormal, mNormal[v.vBlendIndices.x]) * v.vBlendWeights.x +
        mul(v.vNormal, mNormal[v.vBlendIndices.y]) * v.vBlendWeights.y +
        mul(v.vNormal, mNormal[v.vBlendIndices.z]) * v.vBlendWeights.z +
        mul(v.vNormal, mNormal[v.vBlendIndices.w]) * fLastBlendWeight;

  
    // Skin tangent (to world space)
    // A tangent is also influenced by four bones. Tangents, like 
    //   normals, cannot be transformed using the world matrix 
    //   (because they end up with orientation problems if x,y,z 
    //   scaling is not uniform). Tangents need to be transformed 
    //   using the inverse-transpose matrix (mNormal). Otherwise, the transform 
    //   is the same for tangents as it is for normals - each tangent 
    //   is transformed into world space ( using the world matrix 
    //   transpose ) resulting in 4 possible tangent vectors. Weights 
    //   are used to combine all four tangent vectors into a final 
    //   tangent vector.
 
    float3 vTangent =
        mul(v.vTangent, mNormal[v.vBlendIndices.x]) * v.vBlendWeights.x +
        mul(v.vTangent, mNormal[v.vBlendIndices.y]) * v.vBlendWeights.y +
        mul(v.vTangent, mNormal[v.vBlendIndices.z]) * v.vBlendWeights.z +
        mul(v.vTangent, mNormal[v.vBlendIndices.w]) * fLastBlendWeight;



    // Compute binormal
    // The binormal vector is the third axis in tangent space. You already 
    //   have the vertex normal vector and the vertex tangent vector. So, 
    //   a cross product will give you the third axis that is perpendicular 
    //   to the other two axes. To generate an axis in left-handed 
    //   coordinates, the result has to be flipped.
		    float3 vBinormal = cross(vNormal, vTangent) * v.fFlip;        



    // Light direction (to vertex space)
    // Load the vertex tangent, bi-normal, and normal unit vectors 
    //   into a matrix for transforming the light direction vector.

    float3x3 mLight =  
        float3x3(vTangent.x, vBinormal.x, vNormal.x,
                 vTangent.y, vBinormal.y, vNormal.y, 
                 vTangent.z, vBinormal.z, vNormal.z);


    // Displace position    
    // To find the final vertex position, move each vertex with 
    // displacement data in the direction of the normal vector and 
    // transform the vertices into projection space.

    o.vPosition = mul(float4(vPosition + vNormal * v.fDisplacement, 1), 
                      mViewProj);    


    // vDiffuse and vSpecular contain the lights diffuse and specular 
    //   direction. This is a float3 vector. Theses direction vectors 
    //   need to be transformed to projection space also. Once transformed, 
    //   the direction vectors may contain components between -1 and +1. 
    // Because they are being loaded into the pixel shader diffuse and 
    //   specular registers, the data needs to be in the 0 to +1 range. 
    // The data is converted by scaling (* 0.5) and biasing (+ 0.5) 
    //   the data.
 
    o.vDiffuse  = mul(vDiffuse, mLight) * 0.5 + 0.5;
    o.vSpecular = mul(vSpecular, mLight) * 0.5 + 0.5;


    // No change is needed for the texture coordinates, so copy them 
    //   as is to both sets of output texture coordinates.

    o.vTexCoord0.xy = o.vTexCoord1.xy = v.vTexCoords.xy;


    return o;
}

sampler DiffuseMap = sampler_state
{
Texture   = <tDiffuse>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};

sampler NormalMap = sampler_state
{
Texture   = <tNormal>;
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
};


technique T0
{
    pass P0
    {
        // Vertex shader
        VertexShader = compile vs_1_1 main();

        // Pixel shader
        PixelShader =
            asm
            {
                ps_1_1
                tex t0
                tex t1

                // Specular
                dp3_sat r1, t1_bx2, v1_bx2
                dp3_x4  r0, t1_bx2, v0_bx2

                mul_sat r1, r1, r0
                mul_sat r1, r1, r1
                mul_sat r1, r1, c2

                // Diffuse + Ambient
                dp3_sat r0, t1_bx2, v0_bx2          
                mad_sat r0, r0, c1, c0
                mad_sat r0, r0, t0, r1
            };

        PixelShaderConstant1[0] = <cAmbient>;
        PixelShaderConstant1[1] = <cDiffuse>;
        PixelShaderConstant1[2] = <cSpecular>;

        Sampler[0] = (DiffuseMap);
        Sampler[1] = (NormalMap);

        // Clip/Raster state
        CullMode = CW;
    }
}


補遺

キーワード

キーワードは、あらかじめ定義されている予約済みの識別子であり、特別な意味を持っている。プログラム内で識別子として使うことはできない。次のキーワードが予約されている。'*' の付いているキーワードは、大文字小文字を区別しない。

asm*boolcompileconst
decl *dodoubleelse
externfalsefloatfor
halfifininline
inoutintmatrixout
pass *pixelshaderreturnsampler
sharedstaticstringstruct
technique *texturetruetypedef
uniformvectorvertexshadervoid
volatilewhile

次のキーワードは未使用だが、予約されている。

asm*boolcompileconst
autobreakcasecatch
charclassconst_castcontinue
defaultdeletedynamic_castenum
explicitfriendgotolong
mutablenamespacenewoperator
privateprotectedpublicregister
reinterpret_castshortsignedsizeof
static_castswitchtemplatethis
throwtrytypenameunion
unsignedusingvirtual

プリプロセッサ ディレクティブ

プリプロセッサは、次のディレクティブを認識する。下に挙げるディレクティブ以外は、すべて Microsoft Visual C++® プリプロセッサとの互換性を持つように実装される。これらのディレクティブの完全な説明については、Visual C++ のドキュメントを参照すること。

#define#elif#else#endif
#error#if#ifdef#ifndef
#include#linepragma#undef
#row_major#column_major

関数形式の #defines は、まだ実装されていない。次のトークンは自動的に定義される。

#define D3DX
#define D3DX_VERSION 0x0900
#define DIRECT3D
#define DIRECT3D_VERSION 0x0900
#define __FILE__ <current file name>
#define __LINE__ <current line number>

ディレクティブ #include は、ファイルからコンパイルする場合にのみ有効である。ファイル名は、絶対パスで指定しても相対パスで指定してもよい。相対パスで指定した場合は、#include を発行したファイルのディレクトリからの相対パスと見なされる。INCLUDE パスという概念がないため、<filename> 構文はサポートされず、無効である。代わりに "filename" を使うこと。

ディレクティブ #pragma について定義された使用方法がまだなく、認識されない pragma は何も返さずに無視される。

row_major と column_major は、行列変数の格納方法を指定する。次に示すのは、その例とサイズである。

row_major half1x4 fh1By4;
column_major half1x4 fh4By1;
row_major half3x2 fh3By2;
column_major half3x2 fh2By3;

//   matrix name   constant register   size
//     fh4By1            c620           4
//     fh3By2            c624           3
//     fh2By3            c627           2
//     fh1By4            c636           1

このような格納方法は、コンパイラの pragma でも指定できる。

#pragma PACK_MATRIX (ROW_MAJOR)
#pragma PACK_MATRIX (COLUMN_MAJOR)

レジスタを使って、特定の定数を変数と関連付けるよう指定する。次に例を示す。

float4 vColor : register(vs_2_0, c14) ;  

変数 vColor がレジスタ c14 に関連付けられる。

次に、その他の例を示す。

float4 vDisplace : register (c0); // puts the vDisplace constant into C0

これは、次のような複雑な式に使える。

float4 vDisplace : register (c0)    

この式は、バージョン 2.0 以外のピクセル シェーダについて、vDisplace 定数を C0 に格納する。

float4 vDisplace : register(vs, c10)

この式は、すべての頂点シェーダについて、vDisplace 定数を C10 に格納する。

float4 vDisplace : register(ps_2_0, c10) 

この式は、バージョン 2.0 のピクセル シェーダについて、vDisplace 定数を C10 に格納する。

表記規則

空白文字

Space
Tab
EOL
C 形式のコメント (/* */)
C++ 形式のコメント (//)
asm ブロック (;) 内のアセンブリ形式のコメント

浮動小数点数

  • fractional-constant exponent-part(opt) floating-suffix(opt)

    digit-sequence exponent-part floating-suffix(opt)

  • fractional-constant (仮数部) :

    digit-sequence(opt) . digit-sequence

    digit-sequence .

  • exponent-part (指数部) :

    e sign(opt) digit-sequence

    E sign(opt) digit-sequence

  • sign (符号) :次のいずれか 1 つ

    + -

  • digit-sequence (数字列) :

    digit

    digit-sequence digit

  • floating-suffix (浮動小数点サフィックス) :次のいずれか 1 つ

    h H f F

整数

  • integer-constant integer-suffix(opt)
  • integer-constant (整数定数) :次のいずれか 1 つ

    # (10 進数)

    0# (8 進数)

    0x# (16 進数)

  • integer-suffix (整数サフィックス) は、次のいずれか 1 つ。

    u U l L

文字

'c'(文字)
'¥a' '¥b' '¥f' '¥b' '¥r' '¥t' '¥v'(エスケープ)
'¥###'(8 進数エスケープ、各 # は 8 進数)
'¥x#'(16 進数エスケープ。# は 16 進数。任意の数の数字)
'¥c'(c は別の文字。バックスラッシュや引用符も含む)

エスケープはプリプロセッサ式ではサポートされていない。

文字列

"s" (s はエスケープが付いた任意の文字列)

識別子

	[A-Za-z_][A-Za-z0-9_]*

演算子

	##, #@, ++, --, &&;, ||, ==, ::, <<, <<=, >>, >>=, ..., 
	<=, >=, !=, *=, /=, +=, -=, %=, &;=, |=, ^=, ->

さらに、その他の規則と一致しなかった、その他の任意の文字。

構文

プログラム オプション

///////////////////////////////////////////////////
Program         :
                | Decls
                ;
///////////////////////////////////////////////////
Decls           : Decl
                | Decl Decls
                ;
///////////////////////////////////////////////////
Decl            : TypeDecl
                | VariableDecl
                | VarStructDecl
                | FunctionDecl
                | TechniqueDecl
                ;
///////////////////////////////////////////////////

使用方法

///////////////////////////////////////////////////
Usages          : Usage
                | Usage Usages
                ;
///////////////////////////////////////////////////
Usage           : T_KW_STATIC
                | T_KW_UNIFORM
                | T_KW_EXTERN
                | T_KW_VOLATILE
                | T_KW_INLINE
                | T_KW_SHARED
                | Target
                ;
///////////////////////////////////////////////////
UsageType       : Type
                | Usages Type
                ;
///////////////////////////////////////////////////
UsageStructDef  : StructDef
                | Usages StructDef
                ;
///////////////////////////////////////////////////

TypeDecl        : T_KW_TYPEDEF Type TypeDefs ';'
                | StructDef ';'
                ;
///////////////////////////////////////////////////
TypeDefs        : VariableDim
                | VariableDim ',' TypeDefs
                ;
///////////////////////////////////////////////////
TypeDim         : Type
                | TypeDim '[' ConstantExpr ']'
                ;
///////////////////////////////////////////////////
Type            : SimpleType
                | T_KW_CONST SimpleType
                ;
///////////////////////////////////////////////////
SimpleType      : BaseType
                | Struct
                | TypeId
                ;
///////////////////////////////////////////////////
BaseType        : T_KW_VOID
                | ScalarType
                | VectorType
                | MatrixType
                | ObjectType
                ;
///////////////////////////////////////////////////
ScalarType      : T_KW_BOOL
                | T_KW_INT
                | T_KW_HALF
                | T_KW_FLOAT
                | T_KW_DOUBLE
                ;
///////////////////////////////////////////////////
VectorType      : T_KW_VECTOR
                | T_KW_VECTOR '<' ScalarType ',' AddExpr '>'
                ;
///////////////////////////////////////////////////
MatrixType      : T_KW_VECTOR
                | T_KW_VECTOR '<' ScalarType ',' ConstantExpr ',' AddExpr '>'
                ;
///////////////////////////////////////////////////
ObjectType      : T_KW_STRING
                | T_KW_TEXTURE
                | T_KW_SAMPLER
                | T_KW_PIXELSHADER
                | T_KW_VERTEXSHADER
                ;
///////////////////////////////////////////////////

構造体

///////////////////////////////////////////////////
Struct          : T_KW_STRUCT StructStart StructEnd
                | T_KW_STRUCT StructStart StructDecls StructEnd
                ;
///////////////////////////////////////////////////
StructDef       : SimpleStructDef
                | T_KW_CONST SimpleStructDef
                ;
///////////////////////////////////////////////////
SimpleStructDef : T_KW_STRUCT Id StructStart StructEnd
                | T_KW_STRUCT Id StructStart StructDecls StructEnd
                ;
///////////////////////////////////////////////////
StructStart     : '{'
                ;
///////////////////////////////////////////////////
StructDecls     : VariableDecl
                | VariableDecl StructDecls
                ;
///////////////////////////////////////////////////
StructEnd       : '}'
                ;
///////////////////////////////////////////////////

コメント

///////////////////////////////////////////////////
Annotation      : AnnotationStart AnnotationEnd 
                | AnnotationStart AnnotationDecls AnnotationEnd 
                ;
///////////////////////////////////////////////////
AnnnotationStart : '{'
                 ;
///////////////////////////////////////////////////
AnnotationDecls : VariableDecl
                | VariableDecl AnnotationDecls
                ;
///////////////////////////////////////////////////
AnnotationEnd   : '}'
                ;
///////////////////////////////////////////////////

変数

///////////////////////////////////////////////////
VariableDecl    : UsageType Variables ';'
                ;
///////////////////////////////////////////////////
VarStructDecl   : UsageStructDef Variables ';'
                ;
///////////////////////////////////////////////////
Variables       : Variable
                | Variable ',' Variables
                ;
///////////////////////////////////////////////////
Variable        : VariableAnn
                | VariableAnn '=' InitExpr
                ;
///////////////////////////////////////////////////
VariableAnn     : VariableSem
                | VariableSem Annotation
                ;
///////////////////////////////////////////////////
VariableSem     : VariableDim
                | VariableDim ':' Id
                ;
///////////////////////////////////////////////////
VariableDim     : Id
                | VariableDim '[' ConstantExpr ']'
                ;
///////////////////////////////////////////////////

関数

///////////////////////////////////////////////////
FunctionDecl    : FunctionDef FunctionBody
                ;
///////////////////////////////////////////////////
FunctionDef     : UsageType Id ParamList
                | UsageType Id ParamList ':' Id
                ;
///////////////////////////////////////////////////
FunctionBody    : ';'
                | StmtBlock
                ;
///////////////////////////////////////////////////
ParamList       : ParamListStart ParamListEnd
                | ParamListStart T_KW_VOID ParamListEnd
                | ParamListStart ParameterDecls ParamListEnd
                ;
///////////////////////////////////////////////////
ParamListStart  : '('
                ;
///////////////////////////////////////////////////
ParamListEnd    : ')'
                ;
///////////////////////////////////////////////////
ParameterDecls  : ParameterDecl
                | ParameterDecl ',' ParameterDecls
                ;
///////////////////////////////////////////////////
ParameterDecl   : ParamUsageType Variable
                ;
///////////////////////////////////////////////////
ParamUsageType  : Type
                : ParamUsages Type
                ;
///////////////////////////////////////////////////
ParamUsages     : ParamUsage
                : ParamUsage ParamUsages
                ;
///////////////////////////////////////////////////
ParamUsages     : T_KW_IN
                : T_KW_OUT
                : T_KW_INOUT
                : T_KW_UNIFORM
                ;
///////////////////////////////////////////////////

テクニック

///////////////////////////////////////////////////
TechniqueDecl   : T_KW_TECHNIQUE TechniqueBegin TechniqueEnd
                | T_KW_TECHNIQUE Id TechniqueBegin TechniqueEnd
                ;
///////////////////////////////////////////////////
TechniqueBegin  : '{'
                ;
///////////////////////////////////////////////////
TechniqueEnd    : '}'
                | Passes '}'
                ;
///////////////////////////////////////////////////
Passes          : Pass
                | Pass Passes
                ;
///////////////////////////////////////////////////
Pass            : T_KW_PASS PassBegin PassEnd
                | T_KW_PASS Id PassBegin PassEnd
                | VariableDecl
                ;
///////////////////////////////////////////////////
PassBegin       : '{'
                ;
///////////////////////////////////////////////////
PassEnd         : '}'
                | States '}'
                ;
///////////////////////////////////////////////////
States          : State
                | State States
                ;
///////////////////////////////////////////////////
State           : Id StateExprBegin StateExpr StateExprEnd
                | Id '[' Uint ']' StateExprBegin StateExpr StateExprEnd
                ;
///////////////////////////////////////////////////
StateExprBegin  : '='
                ;
///////////////////////////////////////////////////
StateExprEnd    : DwordExpr ';'
                ;
///////////////////////////////////////////////////

SimpleStmt      : ';'
                | Expr ';'
                | T_KW_RETURN ';'
                | T_KW_RETURN Expr ';'
                | T_KW_DO Stmt T_KW_WHILE '(' Expr ')' ';'
                | StmtBlock
                ;
///////////////////////////////////////////////////
NonIfStmt       : SimpleStmt
                | T_KW_WHILE '(' Expr ')' NonIfStmt
                | T_KW_FOR '(' ForInit ForCond ForStep ')' NonIfStmt
                ;
///////////////////////////////////////////////////
Stmt            : SimpleStmt
                | T_KW_WHILE '(' Expr ')' Stmt
                | T_KW_FOR '(' ForInit ForCond ForStep ')' Stmt
                | T_KW_IF '(' Expr ')' Stmt
                | T_KW_IF '(' Expr ')' NonIfStmt T_KW_ELSE Stmt
                ;
///////////////////////////////////////////////////
ForInit         : ';'
                | Expr ';'
                | VariableDecl
                ;
///////////////////////////////////////////////////
ForCond         : ';'
                | Expr ';'
                ;
///////////////////////////////////////////////////
ForStep         :
                | Expr
                ;
///////////////////////////////////////////////////
DeclStmt        : TypeDecl
                | VariableDecl
                | VarStructDecl
                | Stmt
                ;
///////////////////////////////////////////////////
DeclStmts       : DeclStmt
                | DeclStmt DeclStmts
                ;
///////////////////////////////////////////////////
StmtBlock       : StmtBlockStart StmtBlockEnd
                | StmtBlockStart DeclStmts StmtBlockEnd
                ;
///////////////////////////////////////////////////
StmtBlockStart  : '{'
                ;
///////////////////////////////////////////////////
StmtBlockEnd    : '}'
                ;
///////////////////////////////////////////////////

///////////////////////////////////////////////////
DwordExpr       : Dword
                | Dword '|' DwordExpr 
                ;
///////////////////////////////////////////////////
StateExpr       : DwordExpr
                | ComplexExpr 
                | '{' InitExprs '}' 
                | '<' RelationalExpr '>'
                ;
///////////////////////////////////////////////////
SimpleExpr      : T_KW_TRUE
                | T_KW_FALSE
                | UINT
                | Float
                | String
                | NonTypeId
                ;
///////////////////////////////////////////////////
ComplexExpr     : '(' Expr ')'
                | TypeId '(' ArgumentExprs ')'
                | BaseType '(' ArgumentExprs ')'
                | NonTypeId '(' ArgumentExprs ')'
				| Asm
				| AsmDecl
				| AsmDecl Asm
				| T_KW_COMPILE Target NonTypeId '(' ArgumentExpr ')'
                ;
///////////////////////////////////////////////////
Primary         : SimpleExpr
                | ComplexExpr
                ;
///////////////////////////////////////////////////
PostfixExpr     : PrimaryExpr
                | PostfixExpr '[' Expr ']'
                | PostfixExpr '.' Id
                | PostfixExpr T_OP_INC
                | PostfixExpr T_OP_DEC
                ;
///////////////////////////////////////////////////
UnaryExpr       : PostfixExpr
                | T_OP_INC UnaryExpr
                | T_OP_DEC UnaryExpr
                | '!' CastExpr
                | '-' CastExpr
                | '+' CastExpr
                ;
///////////////////////////////////////////////////
CastExpr        : UnaryExpr
                | '(' TypeDim ')' CastExpr
                ;
///////////////////////////////////////////////////
MulExpr         : CastExpr
                | MulExpr '*' CastExpr
                | MulExpr '/' CastExpr
                | MulExpr '%' CastExpr
                ;
///////////////////////////////////////////////////
AddExpr         : MulExpr
                | AddExpr '+' MulExpr
                | AddExpr '-' MulExpr
                ;
///////////////////////////////////////////////////
RelationalExpr  : AddExpr
                | RelationalExpr '<' AddExpr
                | RelationalExpr '>' AddExpr
                | RelationalExpr T_OP_LE AddExpr
                | RelationalExpr T_OP_GE AddExpr
                ;
///////////////////////////////////////////////////
EqualityExpr    : RelationalExpr
                | EqualityExpr T_OP_EQ RelationalExpr
                | EqualityExpr T_OP_NE RelationalExpr
                ;
///////////////////////////////////////////////////
AndExpr         : EqualityExpr
                | AndExpr T_OP_AND EqualityExpr
                ;
///////////////////////////////////////////////////
OrExpr          : AndExpr
                | OrExpr T_OP_OR AndExpr
                ;
///////////////////////////////////////////////////
AssignmentExpr  : OrExpr
                | CastExpr '=' AssignmentExpr
                | CastExpr T_OP_ME AssignmentExpr
                | CastExpr T_OP_DE AssignmentExpr
                | CastExpr T_OP_RE AssignmentExpr
                | CastExpr T_OP_AE AssignmentExpr
                | CastExpr T_OP_SE AssignmentExpr
                ;
///////////////////////////////////////////////////
ConditionalExpr : AssignmentExpr
                | AssignmentExpr  '?' AssignmentExpr  ':' ConditionalExpr
                ;
///////////////////////////////////////////////////
ArgumentExprs   : ConditionalExpr
                | ConditionalExpr ',' ArgumentExprs
                ;
///////////////////////////////////////////////////
ArgumentExpr    : ArgumentExpr
                ;
///////////////////////////////////////////////////
ArgumentExprs   : ArgumentExpr
                ;
///////////////////////////////////////////////////
InitExpr        : ConditionalExpr
                | '{' InitExprs '}'
                ;
///////////////////////////////////////////////////
InitExprs       : InitExpr
                | InitExpr ',' InitExprs
                ;
///////////////////////////////////////////////////
ConstantExpr    : ConditionalExpr
                ;
///////////////////////////////////////////////////
Expr            : ConditionalExpr
                | ConditionalExpr ',' Expr
                ;
///////////////////////////////////////////////////

トークン

///////////////////////////////////////////////////
Dword           : Uint
                | '-' Uint
                | Float
                | '-' Float
                | DwordId
                | Uint DwordId
                ;
///////////////////////////////////////////////////
DwordId         : Id
                | T_KW_TRUE
                | T_KW_FALSE
                | T_KW_TEXTURE
                ;
///////////////////////////////////////////////////
Id              : TypeId
                | NonTypeId
                ;
///////////////////////////////////////////////////
Target          : NonTypeId
                ;
///////////////////////////////////////////////////
Uint            : T_UINT
                | T_INT32
                | T_UINT32
                ;
///////////////////////////////////////////////////
Float           : T_FLOAT
                | T_FLOAT16
                | T_FLOAT32
                | T_FLOAT64
                ;
///////////////////////////////////////////////////
String          : T_STRING
                ;
///////////////////////////////////////////////////
TypeId          : T_TYPE_ID
                ;
///////////////////////////////////////////////////
NonTypeId       : T_NON_TYPE_ID
                ;
///////////////////////////////////////////////////
Asm             : T_KW_ASM '{'
                ;
///////////////////////////////////////////////////
AsmDecl         : T_KW_DECL '{'
                ;
///////////////////////////////////////////////////
表示: