DirectX Graphics 레퍼런스 셰이더 레퍼런스 상위 레벨 셰이더 언어   [목차열람] [주소복사] [슬롯비우기]
상위 레벨 셰이더 언어
 
Microsoft DirectX 9.0

상위 레벨 셰이더 언어

셰이더를 어셈블리 언어로 기술하는 것이 큰 일인 때는, 상위 레벨 셰이더 언어 (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 extension (D3DX) 8.0 이펙트와의 호환성을 유지하기 위해서(때문에), 다음의 형태는 자동적으로, 슈퍼 글로벌 스코프로 대문자 소문자가 구별되지 않는 형태로 정의된다. 

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

편의상, 다음의 형태는 자동적으로 슈퍼 글로벌 스코프로 정의된다(이러한 정의에서는, 샤프 기호는 1 ~ 4 의 숫자를 나타낸다). 

	typedef vector bool#;
	typedef vector int#;
	typedef vector half#;
	typedef vector float#;
	typedef vector double#;

	typedef matrix bool#x#;
	typedef matrix int#x#;
	typedef matrix half#x#;
	typedef matrix float#x#;
	typedef matrix 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 를 접두어에 사용할 수 있다. 이것은, 이 파라미터의 값의 목적은, 이펙트 개체간에 공유하는 것이라고 하는, 이펙트 프레임워크(framework)에 대한 힌트이다.

글로벌 변수의 선언에서는, 키워드 volatile 를 접두어에 사용할 수 있다. 이것은, 이 파라미터의 값이 빈번하게 바뀐다고 하는, 이펙트 프레임워크(framework)에 대한 힌트이다.

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)형 constructor　 　왼쪽에서 오른쪽
[]array[int]배열의 첨자왼쪽에서 오른쪽
. structure.id멤버의 선택왼쪽에서 오른쪽
value.swizzle성분의 교체왼쪽에서 오른쪽
++variable++후 치인크리먼트(increment) (성분마다)왼쪽에서 오른쪽
--variable--후 치감소 (성분마다)왼쪽에서 오른쪽
++++variable전치인크리먼트(increment) (성분마다)오른쪽에서 왼쪽
----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 라고 보여진다.

본체가 없는 함수를 정의 하면, prototype라고 보여진다. 이 함수는, 후의 코드로 본체를 붙여 재정의할 필요가 있다. 본체가 정의되지 않은 함수를 참조 하면, 에러가 된다.

함수는, 다중 정의 할 수 있다. 함수는, 그 이름, 인수의 형태, 타겟 플랫폼 (지정되고 있는 경우)에 의해 일의에 식별된다. 함수의 다중 정의는, 아직 처리되지 않다.

현시점에서는, 모든 함수가 인 라인이다. 재귀는 지원하지 않는다.

편입 함수

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 는, 참조가 실행되기 직전의 성분으로 나눗셈 된다.
texCUBEbiastexCUBEbias(s, t)3D 의 바이어스 큐브 텍스처 참조. s 는 샘플러 또는 samplerCUBE 개체. t 는 4D 벡터. 참조를 실행하기 전에, 밉레벨에 t.w 의 바이어스를 걸칠 수 있다.
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정점 포그(안개: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__ 
#define __LINE__

지시문 #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 블록 (;) 내의 어셈블리 형식의 코멘트

부동 소수점수(실수)

정수

문자

'c'(문자)
'\a' '\b' '\f' '\b' '\r' '\t' '\v'(이스케이프)
'\###'(8 진수 이스케이프, 각 # 은 8 진수)
'\x#'(16 진수 이스케이프. # (은)는 16 진수. 임의의 수의 숫자)
'\c'(c 는 다른 문자. backslash나 인용부호도 포함한다)

이스케이프는 프리프로세서식에서는 지원하지 않는다.

캐릭터 라인

"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 '{'
                ;
///////////////////////////////////////////////////

© 2002 Microsoft Corporation. All rights reserved.
↑TOP