상위 레벨 셰이더 언어

셰이더를 어셈블리 언어로 기술하는 것이 큰 일인 때는, 상위 레벨 셰이더 언어 (HLSL: High Level Shader Language)를 사용해 보면 좋다. Microsoft® DirectX® 9.0 에는 상위 레벨 셰이더 언어의 최초의 릴리스가 포함되어 있어 C 를 닮은 고급언어로 셰이더를 개발 및 디버그 할 수 있다. 이 기능은, DirectX 8.0 으로부터 장비 된 정점 셰이더, 픽셀 셰이더, 이펙트의 생성에 사용하는 셰이더의 어셈블리 언어의 셰이더 기능과는 다른 추가 기능이다.

상위 레벨 셰이더 언어에서는, C 를 닮은 함수로부터의 셰이더 개발을 지원 하고 있다. 이 언어는, 함수, 식, 문장, 표준 데이터형, 사용자 정의 데이터형, 프리프로세서 지시문 등, 많은 표준적인 언어 기능을 향후 지원 한다.

• 데이터형
• 스칼라-형태
• 벡터형
• 행렬형
• 개체형
• 구조 체형
• 사용자 정의형
• 형태 변환
• 변수
• 문장과 식
• 식
• 함수
• 사용자 정의 함수
• 편입 함수
• 셰이더 의미들
• 정점 셰이더 입력 의미들
• 정점 셰이더 출력 의미들
• 픽셀 셰이더 입력 의미들
• 픽셀 셰이더 출력 의미들
• 예
• 보유
• 키워드
• 프리프로세서 지시문
• 표기
• 구문

데이터형

스칼라-형태

모든 타겟 플랫폼이 정수값을 네이티브로 지원 하고 있는 것은 아니다. 정수값은, 부동 소수점수(실수)용 하드웨어를 사용해 에뮬레이트 하는 것이 필요한 경우가 있다. 이러한 플랫폼상에서, 정수의 범위를 넘어 부동 소수점수(실수)로서 나타내질 가능성이 있는 정수 연산은, 예측대로 동작 하면 말하는 보증은 없다.

모든 타겟 플랫폼이 half 값 또는 double 값을 네이티브로 지원 하고 있는 것은 아니다. 타겟 플랫폼이 지원 하고 있지 않는 경우, 이러한 값은 부동 소수점수(실수) (float)를 사용해 에뮬레이트 된다. 부동 소수점수(실수)식의 중간 결과는, 오퍼랜드나 결과보다 고정밀도로 평가된다.

벡터형

벡터의 각 성분에는, 배열 액세스 구문을 사용해, 인덱스에 의해 액세스 할 수 있다. 다음에 예를 나타낸다.

vec[0]		(vec.x 와 같다)
vec[3]		(vec.w 와 같다)

벡터의 각 성분에는, 구조체 멤버 액세스 구문을 사용해, 이름에 의해 액세스 할 수 있다. 벡터에 대해서 다음의 성분명세트가 정의되고 있다.

Default set
 x	 y	 z	 w

Color set
 r	 g	 b	 a

벡터의 교체 성분을 포함한 벡터는, 복수의 성분명을 연결하는 것으로 형성할 수 있다. 예를 들어, yyzw 나 bgr 등이다. 연결하는 이름은 모두, 같은 이름 세트의 이름을 지정하는 것. 같은 성분은 여러 차례 반복 지정할 수 있지만, 그 경우, 교체는 할당의 타겟으로서는 무효이다.

행렬형

행렬의 각 열에는, 배열 액세스 구문을 사용해, 인덱스에 의해 액세스 할 수 있다. 다음에 예를 나타낸다.

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#;

형태 변환

변수

변수는 다음과 같이 선언한다.

[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 성분에는, 다음의 이름표에 나타내는 첨자를 사용해, 구조체 멤버에의 액세스와 닮은 방법으로 액세스 할 수 있다.

이러한 이름을 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 문은 아직 처리되지 않다.

식

식은, 리터럴, 변수, 또는 리터럴과 변수를 「보유」의 연산자 우선 순위표에 있는 연산자로 결합한 것이다.

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라고 보여진다. 이 함수는, 후의 코드로 본체를 붙여 재정의할 필요가 있다. 본체가 정의되지 않은 함수를 참조 하면, 에러가 된다.

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

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

편입 함수

셰이더 의미들

• 정점 셰이더 입력 의미들
• 정점 셰이더 출력 의미들
• 픽셀 셰이더 입력 의미들
• 픽셀 셰이더 출력 의미들

정점 셰이더 입력 의미들

입력 의미들은, 정점 셰이더 입력 데이터의 사용 방법을 식별하는 코멘트이다. 이것은, 고정 기능 파이프라인의 D3DDECLUSAGE 인수와 유사하다.

n 는 옵션의 정수이다. 예 : PSIZE0, DIFFUSE1.

정점 셰이더 출력 의미들

출력 의미들은, 정점 셰이더 출력 데이터의 사용 방법을 식별하는 코멘트이다. 이것은, 고정 기능 파이프라인의 D3DDECLUSAGE 인수와 유사하다.

n 는 옵션의 정수이다. 예 : texcoord0.

픽셀 셰이더 입력 의미들

입력 의미들은, 픽셀 셰이더 입력 데이터의 사용 방법을 식별하는 코멘트이다. 이것은, 고정 기능 파이프라인의 D3DDECLUSAGE 인수와 유사하다.

n 는 옵션의 정수이다. 예 : TEXCOORD0, TEXCOORD1.

픽셀 셰이더 출력 의미들

출력 의미들은, 픽셀 셰이더 출력 데이터의 사용 방법을 식별하는 코멘트이다.

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;
    }
}

보유

• 키워드
• 프리프로세서 지시문
• 표기
• 구문

키워드

키워드는, 미리 정의되고 있는 예약 끝난 식별자이며, 특별한 의미를 가지고 있다. 프로그램내에서 식별자로서 사용할 수 없다. 다음의 키워드가 예약되고 있다. '*'가 붙어 있는 키워드는, 대문자 소문자를 구별하지 않는다.

다음의 키워드는 미사용이지만, 예약되고 있다.

프리프로세서 지시문

프리프로세서는, 다음의 지시문을 인식한다. 아래에 올리는 지시문 이외는, 모두 Microsoft Visual C++® 프리프로세서와의 호환성을 가지도록(듯이) 처리 된다. 이러한 지시문의 완전한 설명에 대해서는, Visual C++ 의 문서를 참조할것.

함수 형식의 #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 에 저장 한다.

표기 규칙

공백 문자

부동 소수점수(실수)

• 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

문자

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

캐릭터 라인

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