High Level Shader Language

**HLSL** () — C-բարձր կարգի ծրագրավորման լեզու։
350px|right

Թողարկված է Microsoft ընկերության կողմից և աշխատում է DirectX 9.0 փաթեթում։

## Տվյալների տիպեր
HLSL- ն աջակցում է սկալյար տեսակներ, վեկտորային տեսակ, մատրիցներ և կառուցվածքներ։
### Սկալյար տիպեր
* bool — բուլյան տեսակ
* int — ամբողջ մեծություն 32 բիթ ամբողջ մեծություն
* half — սողացող կետով 16 բիթ մեծություն
* float — սողացող կետով 32 բիթանոց մեծություն
* double — սողացող կետով 64 վիթանոց մեծություն
### Վեկտորային տիպեր
Օրինակ՝ vector  color;

Օրինակ՝ float4 newcolor;

Օրինակ՝ float oldcolor[4]

Օրինակ՝ newcolor = float4(oldcolor[0], oldcolor[1], oldcolor[2], oldcolor[3])
### մատրիցներ
Օրինակ՝ matrix  view_matrix;

Օրինակ՝ float 4x4 view_matrix;
### Կառուցվածքներ
struct vs_input
{
: float4 pos:POSITION;
: float3 nor:NORMAL;
: float2 uv:TEXCOORD0;

};
struct ps_input
{
: float4 pos:POSITION;
: float3 nor:NORMAL;
: float2 uv:TEXCOORD0;
: float CustomVar;
: texture2D CustomTexture;
: //и так далее… :POSITION :NORMAL и т. д. это сентиматики, о них ниже.
};

## Օպերատորներ

## Պայման
**if** (արտհյտություն)  [**else** ]
## Ցիկլեր
HLSL կոդում տարբերում են ցիկլի երեք գրռումներ։
* **do**  **while** ();
* **while** () ;
* **for** (; ; ) 

## Ֆունկցիաներ

### Մաթեմատիկական ֆունկցիա

### Ֆունկցիներ գրվածքների հետ աշխատելու համար

## Մուտքի և ելքի տվյալներ
Վերին և ֆրագմենտային շեյդերը ունենում են երկույալներ՝ 'varying* և *uniform*.

*'Uniform** —տվյալներ, որոնք անընդհատ են շեյդերի բազմակի կիրառման համար։ uniform տվյալների հայտարարում HLSL-ում կարելի է կատարել երկու եղանակով.

1)Հայտարարել տվյալները որպես extern փոփոխականներ, օրինակ.

<pre>
float4 value;

float4 main () : COLOR
{
  return value;
}
</pre>

2)Հայտարարել տվյալները uniform որոշիչի միջոցով, օրինակ.

<pre>
float4 main (uniform float4 value) : COLOR
{
  return value;
}
</pre>

Uniform փոփոխականները սահմանվում են հաստատուն աղյուսակում։ Հաստատուն աղյուսակը պարունակում է այն բոլոր ռեգիստորները, որոնք մշտապես օգտագործվում են shader- ում։

**Varying''' — Տվյալներ, որոնք յուրահատուկ են յուրաքանչյուր shader կանչի համար։ Օրինակ։ դիրք, նորմալ և այլն։ 
Հիմնական մուտքային semantic տիպեր։

Կիրառելով varying անցում է կատարվում այլ վիճակի.
Հիմնական մուտքային semantic տիպեր։

Մուտքային տվյալներ։

Արտածման տվյալներ։

## Օրինակներ

### Պարզագույն շեյդեր «Texture mapping»
Այս ծրագրային կոդն աշխատում է ATI Rendermonkey և Nvidia FX composer ծրագրային ապահովումներում։
Շարժվող պատկեր ստեղծելու համար պետք է հայտարարել SamplerState և technique:

```glsl
/* ========== Վերին շեյդեր ========== */
/* world_matrix, view_matrix, proj_matrix необходимо получить из приложения, установив константы шейдера. 
ում են Շեյդերի հաստատունները բեռնվումների մեջ։ */
float4x4 world_matrix; //հիմնական մատրից
float4x4 view_matrix;  // ձևի մատրից
float4x4 proj_matrix;  // նախագծի մատրից

struct VS_OUTPUT //այս կառույցի նպատակն է վերադարձնել վերին շեյդերը
{
   float4 Pos: POSITION0; /* POSITION0 и TEXCOORD0 -Կարելի է տարբերել փոփոխականներն ու նրանց տիպերը:*/
   float2 TexCoord: TEXCOORD0;
};

VS_OUTPUT VS_Main(float4 InPos: POSITION0, float2 InTexCoord : TEXCOORD0) /* Վերադարձնում է օբյեկտն ու նրա տիպը. InPos և InTexCoord ստացվում են stream-mapping'a տվյալներից */
{
   VS_OUTPUT Out;

   float4x4 worldViewProj_matrix = mul(world_matrix, view_matrix);
   worldViewProj_matrix = mul(worldViewProj_matrix, proj_matrix);

   Out.Pos = mul(InPos,  worldViewProj_matrix); // վերափոխում է clip-space
   Out.TexCoord = InTexCoord; // Ստացվում են տեքստային կոորդինատներ, սակայն կառուցվածքում ոչինչ չի փոխվում
   return Out;
}

/* ========== Փիքսելային շեյդեր ========== */

sampler2D baseMap; // sampler2D - հատուկ բլոկ "տեքստային բլոկ" որի մեջ կարելի է բեռնել տեքստուրա.

float4 PS_Main(float2 texCoord: TEXCOORD0) : COLOR0 /* Պիկսելային շեյդերը միշտ վերադարձնում են պատկերի գույնը
pixel- ը semantics- ի COLOR0 ձեւաչափով float4: Պատկերի յուրաքանչյուր պիքսելի համար կատարվում է պիքսելային ստվեր
պատկերի մակերեսին (և ոչ թե տեքստելի կառուցվածքների համար) */
{
   return tex2D( baseMap, texCoord ); /* tex2d(sampler2D, float2) կարդում է 
տեքստուրայից նշված փիքսելի գույնը։ */
}
```


### պարզագույն շեյդեր «Գլխապտույտ»


```glsl
float4x4 view_proj_matrix: register(c0);

struct VS_OUTPUT 
{
   float4 Pos: POSITION;
   float2 texCoord: TEXCOORD0;
};

VS_OUTPUT VS_Dizzy(float4 Pos: POSITION)
{
   VS_OUTPUT Out;

   Pos.xy = sign(Pos.xy);

   Out.Pos = float4(Pos.xy, 0, 1);
   Out.texCoord = Pos.xy;

   return Out;
}

float time_0_X: register(c0);
float rings: register(c1);
float speed: register(c2);
float exponent: register(c3);

float4 PS_Dizzy(float2 texCoord: TEXCOORD0) : COLOR 
{
   float ang = atan2(texCoord.x, texCoord.y);
   float rad = pow(dot(texCoord, texCoord), exponent);

   return 0.5 * (1 + sin(ang + rings * rad + speed * time_0_X));
}
```


### Էլեկտրական հոսանքի մոդել
\

```glsl
struct VS_OUTPUT 
{
   float4 Pos: POSITION;
   float2 texCoord: TEXCOORD;
};

VS_OUTPUT VS_Electricity(float4 Pos: POSITION)
{
   VS_OUTPUT Out;

   // Clean up inaccuracies
   Pos.xy = sign(Pos.xy);

   Out.Pos = float4(Pos.xy, 0, 1);
   Out.texCoord = Pos.xy;

   return Out;
}

float4 color: register(c1);
float glowStrength: register(c2);
float height: register(c3);
float glowFallOff: register(c4);
float speed: register(c5);
float sampleDist: register(c6);
float ambientGlow: register(c7);
float ambientGlowHeightScale: register(c8);
float vertNoise: register(c9);
float time_0_X: register(c0);
sampler Noise: register(s0);

float4 PS_Electricity(float2 texCoord: TEXCOORD) : COLOR 
{
   float2 t = float2(speed * time_0_X * 0.5871 - vertNoise * abs(texCoord.y), speed * time_0_X);

   // Sample at three positions for some horizontal blur
   // The shader should blur fine by itself in vertical direction
   float xs0 = texCoord.x - sampleDist;
   float xs1 = texCoord.x;
   float xs2 = texCoord.x + sampleDist;

   // Noise for the three samples
   float noise0 = tex3D(Noise, float3(xs0, t));
   float noise1 = tex3D(Noise, float3(xs1, t));
   float noise2 = tex3D(Noise, float3(xs2, t));

   // The position of the flash
   float mid0 = height * (noise0 * 2 - 1) * (1 - xs0 * xs0);
   float mid1 = height * (noise1 * 2 - 1) * (1 - xs1 * xs1);
   float mid2 = height * (noise2 * 2 - 1) * (1 - xs2 * xs2);

   // Distance to flash
   float dist0 = abs(texCoord.y - mid0);
   float dist1 = abs(texCoord.y - mid1);
   float dist2 = abs(texCoord.y - mid2);

   // Glow according to distance to flash
   float glow = 1.0 - pow(0.25 * (dist0 + 2 * dist1 + dist2), glowFallOff);

   // Add some ambient glow to get some power in the air feeling
   float ambGlow = ambientGlow * (1 - xs1 * xs1) * (1 - abs(ambientGlowHeightScale * texCoord.y));

   return (glowStrength * glow * glow + ambGlow) * color;
}
```


### Պլաստիլինե մոդել


```glsl
float4x4 view_proj_matrix: register(c0);

float4 view_position: register(c4);

struct VS_OUTPUT 
{
	float4 Pos: POSITION;
	float3 normal: TEXCOORD0;
	float3 viewVec: TEXCOORD1;
};

VS_OUTPUT VS_Plastic(float4 Pos: POSITION, float3 normal: NORMAL)
{
	VS_OUTPUT Out;

	Out.Pos = mul(view_proj_matrix, Pos);

	Out.normal = normal;
	Out.viewVec = view_position - Pos;

	return Out;
}

float4 color: register(c0);

float4 PS_Plastic(float3 normal: TEXCOORD0, float3 viewVec: TEXCOORD1) : COLOR 
{
	float v = 0.5 * (1 + dot(normalize(viewVec), normal));

	return v * color;
}
```


### Փայտե մակերևույթի իմիտացիա


```glsl
float trunk_wobble_frequency;

float4x4 view_matrix;
float4x4 view_proj_matrix;

float4x4 texture_matrix0;
float4x4 texture_matrix1;
float4x4 texture_matrix2;

struct VS_OUTPUT
{
	float4 Pos : POSITION;
	float3 TCoord0 : TEXCOORD0;
	float3 TCoord1 : TEXCOORD1;
	float3 TCoord2 : TEXCOORD2;
	float3 TCoord3 : TEXCOORD3;
	float3 TCoord4 : TEXCOORD4;
	float3 TCoord6 : TEXCOORD6;
	float3 TCoord7 : TEXCOORD7;
};

VS_OUTPUT VS_Wood (float4 vPosition: POSITION, float3 vNormal: NORMAL)
{
	VS_OUTPUT Out = (VS_OUTPUT) 0;
	float4 TransformedPshade;

	// Transform position to clip space
	Out.Pos = mul (view_proj_matrix, vPosition);

	// Transform Pshade (using texture matrices) and output to pixel shader
	TransformedPshade = mul (texture_matrix0, vPosition);
	Out.TCoord0 = TransformedPshade;
	Out.TCoord1 = mul (texture_matrix1, vPosition);
	Out.TCoord2 = mul (texture_matrix2, vPosition);

	// Create two coordinates for sampling noise volume to get wobble
	Out.TCoord3 = float3(trunk_wobble_frequency * TransformedPshade.z, 0.0f, 0.0f);
	Out.TCoord4 = float3(trunk_wobble_frequency * TransformedPshade.z + 0.5f, 0.0f, 0.0f);

	// Transform position and normal to eye space
	Out.TCoord6 = mul (view_matrix, vPosition);
	Out.TCoord7 = mul (view_matrix, vNormal);

	return Out;
}

float4 light_pos;
float4 eye_pos;
float4 light_wood_color;
float4 dark_wood_color;

float noise_amplitude;
float trunk_wobble_amplitude;
float ring_freq;

sampler noise_volume;
sampler pulse_train;
sampler variable_specular;

float4 PS_Wood (float3 Pshade0 : TEXCOORD0,
				float3 Pshade1 : TEXCOORD1,
				float3 Pshade2 : TEXCOORD2,
				float3 zWobble0 : TEXCOORD3,
				float3 zWobble1 : TEXCOORD4,
				float3 Peye : TEXCOORD6,
				float3 Neye : TEXCOORD7) : COLOR
{
	float3 coloredNoise;
	float3 wobble;

	// Construct colored noise from three samples
	coloredNoise.x = tex3D (noise_volume, Pshade0);
	coloredNoise.y = tex3D (noise_volume, Pshade1);
	coloredNoise.z = tex3D (noise_volume, Pshade2);

	wobble.x = tex3D (noise_volume, zWobble0);
	wobble.y = tex3D (noise_volume, zWobble1);
	wobble.z = 0.5f;

	// Make signed
	coloredNoise = coloredNoise * 2.0f - 1.0f;
	wobble = wobble * 2.0f - 1.0f;

	// Scale noise and add to Pshade
	float3 noisyWobblyPshade = Pshade0 + coloredNoise * noise_amplitude + wobble * trunk_wobble_amplitude;

	float scaledDistFromZAxis = sqrt(dot(noisyWobblyPshade.xy, noisyWobblyPshade.xy)) * ring_freq;

	// Lookup blend factor from pulse train
	float4 blendFactor = tex1D (pulse_train, scaledDistFromZAxis);

	// Blend wood colors together
	float4 albedo = lerp (dark_wood_color, light_wood_color, blendFactor.x);

	// Compute normalized vector from vertex to light in eye space (Leye)
	float3 Leye = (light_pos - Peye) / length(light_pos - Peye);

	// Normalize interpolated normal
	Neye = Neye / length(Neye);

	// Compute Veye
	float3 Veye = -(Peye / length(Peye));

	// Compute half-angle
	float3 Heye = (Leye + Veye) / length(Leye + Veye);

	// Compute N.H
	float NdotH = clamp(dot(Neye, Heye), 0.0f, 1.0f);

	// Scale and bias specular exponent from pulse train into decent range
	float k = blendFactor.z;

	// Evaluate (N.H)^k via dependent read
	float specular = tex2D (variable_s
```

## Ծանոթագրություններ

Կատեգորիա:Ծրագրավորման լեզուներ