此笔记用于记录D3D中的HLSL学习过程和重点============================================================================
HLSL : High Level Shader Language 译为：高级着色语言
HLSL语言的语法类似于C语言
1. 数据类型
HLSL中的数据类型有：标准数据类型、向量、矩阵和复杂数据类型。
———|———————————————————————————————————|
类型 取值
———|———————————————————————————————————|
bool TRUE或FALSE
———|———————————————————————————————————|
int 32位signed整形
———|———————————————————————————————————|
half 16位float数值
———|———————————————————————————————————|
double 64位float数值
———|———————————————————————————————————|
float 32位float数值
———|———————————————————————————————————|
1.1 变量声明
常规声明 float fVar ;
声明时初始化 float fVar = 1.0f ;
数组声明 int iVar[3] = {1 ,2 ,3} ; // 声明一个大小为3的整型数组,并初始化为1 ，2，3.
1.2 类型修饰符
(1) const 常量 其值不可改
此类型修饰符表明一个变量的数值不可被渲染代码修改。例如：
const float fConstant = 2.0f ;
同C语言一样，其声明时徐初始化。
1.3 row_major与col_major
这一对修饰符出现在定义一个矩阵时。将其放在矩阵之前，例如：
row_major float 4x4 WorldMatrix ;
其作用在于指定当前定义的矩阵中的元素，使用行主序还是列主序进行存放（矩阵的行列式）。
示例：
col_major 11 12 13 14
21 22 23 24
31 32 33 34
41 42 43 44
row_major 11 21 31 41
12 22 32 42
13 23 33 43
14 24 34 44
行或者列主序决定了从常量表或从渲染器输入中读取矩阵元素的顺序。
1.4 寄存器类型修饰符
寄存器类型修饰符用于高速编译器变量的作用域和生命期
(1) static
static float fVale = 1.11f ;
具全局作用。Static关键字防止渲染器变量暴露给应用程序。
同C语言一样，在函数内部的变量，其值保存到下一次调用。
(2) extern
extern float4 fExternal ;
与Static相反。其义同C语言关键字。
(3) uniform
uniform float fUniforVal = 3.0f ;
只可使用API方法改变它，且只在两次绘制间改变。
(4) shared
shared修饰全局Shader变量表明它在不同的效果中被共享。
shared float fSharedVal ;
2 向量
(1) 向量类型是一种特殊的数据结构，一个向量可能包含1-4个元素。例如：
注意：数据类型后跟的数字，表明向量的维度。
声明1
bool bVector ; 标量 1个bool型数据
bool1 bVector ; 向量，包含一个bool变量
int1 iVector ; 向量，包含一个int变量
half2 hVector ; 向量，包含两个half变量
float3 fVector ; 向量，包含三个float变量
double4 fVector ; 向量，包含四个double变量
变量声明初始化可以同时进行
bool1 bVector = FALSE ;
int1 iVector = 1 ;
half2 hVector = {0.2 ,0.3} ;
float3 fVector = {0.3f ,0.4f ,0.5f} ;
double4 dVector = {0.2 ,0.3 ,0.4 ,0.5} ;
声明2
当声明向量时，可以在一个尖括号中指定该向量的类型和向量中的元素个数。
vector<bool ,1> bVector = TRUE ;
vector<int ,1> iVector = 1 ;
vector<half ,2> hVector = {0.2 ,0.3 } ;
vector<float ,3> fVector = {1.0f ,2.0f ,3.0f} ;
vector<double ,4> dVector = {1.0 ,2.0 ,3.0 ,4.0} ;
(2)向量元素的存取
一个向量最多包含4个元素。可使用位置x、y、z、w和颜色r、g、b、a进行寻址。
float4 Pos = float4{0.0f ,1.0f ,2.0f ,3.0f} ;
对于向量Pos，使用Pos.z和Pos.b都返回第三个元素，即2.0f。
在一次存取过程中，可以使用一个命名集合获取一个或多个元素，但命名集合不能混用。
如：
float4 Pos = float4(1.0f ,2.0f ,3.0f ,4.0f) ;
float2 Temp ;
Temp = Pos.xy ; // 正确 x y命名相同
Temp = Pos.rg ; // 正确 r g命名相同
Temp = Pos.xb ; // 错误x b命名混用
(3)向量元素的混合存取
将读取一个或多个指定的向量元素，称之为混合存取(swizzling).
存取示例：
float4 pos = float4(0 , 0 , 2 ,1) ;
float2 f_2D ;
f_2D = pos.xy ; // 读取两个元素x和y，并赋值给f_2D
f_2D = pos.xz ; // 读取pos的x和z，赋值给f_2D,可以以任何顺序读取元素
f_2D = pos.zx ; // 元素可逆序读取
f_2D = pos.xx ; // 重复读取，元素可以多次读取
f_2D = pos.yy ; // 同上
赋值操作
float4 pos = float4(0 ,0 ,2 ,1) ;
float4 f_4D ;
f_4D = pos ; // 相当于f_4D.x = pos.x ; f_4D.y = pos.y ; f_4D.z = pos.z ;f_4D.w = pos.w ;
f_4D.xz = pos.xz ; // 等同于f_4D.x = pos.x ; f_4D.z = pos.z ;
f_4D.zx = pos.xz ; // 等同于f_4D.z = pos.x ; f_4D.x = pos.z ;
f_4D.xyzw = pos.w ;// 等同于f_4D.x = pos.w ; f_4D.y = pos.y ;f_4D.z = pos.z ;
f_4D.wzyx = pos ; //等同于 f_4D.w = pos.x ; f_4D.z = pos.y ;f_4D.y = pos.z ; f_4D.x = pos.x ;
以下语句无效
f_4D.xx = pos.xy ;
f_4D.xg = pos.rg ;
(4)向量的数学运算
乘法符号为“*“
假设a ,b都为float4类型
float4 v = a * b ;
可视为：
v.x = a.x * b.x ;
v.y = a.y * b.y ;
v.z = a.z * b.z ;
v.w = a.w * b.w ;
此为点乘
3 矩阵
(1)
矩阵是一种以行和列将数据组织起来的数据结构。
矩阵数据类型后紧跟x指明该矩阵的行和列。例如：
int1x1 iMatrix 整形矩阵，1行1列
int2x1 iMatrix 整形矩阵，2行1列
int4x1 iMatrix 整形矩阵，4行1列
int1x4 iMatrix 整形矩阵，1行4列
double1x1 dMatrix double型矩阵，1行1列
double2x2 dMatrix double型矩阵，2行2列
double3x3 dMatrix double型矩阵，3行3列
double4x4 dMatrix double型矩阵，4行4列
HLSL中矩阵的行和列数最大为4，最小为1
矩阵的声明和初始化
float2x2 fMatrix ={0.0f ,0.1f , // 第一行
2.1f ,2.2f} ; // 第二行
matrix <float ,2 ,2> fMatrix ={0.0f ,0.1 // 第一行
2.1f ,2.2f } ; // 第二行
使用关键字matrix声明。这是一个矩阵，其类型为float，行数和列数都为2。
(2) 矩阵元素的存取
矩阵时以行和列将数据组织起来的，可以通过结构体操作符"."来存取其中的数据。
存取方法有两种
1. 0基准行列位置法
_m00, _m01, _m02 ,_m03
_m10 ,m_11 ,_m12 ,_m13
_m20 ,m_21 ,_m22 ,_m23
_m30 ,m_31 ,_m32 ,_m33
2. 1基准行列位置法
_11 ,_12 ,_13 ,_14
_21 ,_22 ,_23 ,_24
_31 ,_32 ,_33 ,_34
_41 ,_42 ,_43 ,_44
两种方法中，每个元素的标识都是以下划线开始的，后跟行号和列号。
0基准位置法中，行号和列号前还有一个字母m。
访问示例：
float2x2 fMatrix ={1.0f ,1.1f ,2.0f ,2.1f} ;
float f_1D ;
f_1D = fMatrix._m00 ; // 取行1、列1数据 1.0f
f_1D = fMatrix._m11 ; // 取行2、列2数据 2.1f
f_1D = fMatrix._11 ; // 取行1、列1数据 1.0f
f_1D = fMatrix._22 ; // 取行2,、列2数据 2.1f
访问矩阵多个元素
float2x2 fMatrix ={1.0f ,1.1f ,2.0f ,2.1f} ;
float temp ;
temp = fMatrix._m00_m11 ;
temp = fMatrix._m11_m00 ;
temp = fMatrix._11_22 ;
temp = fMatrix._22_11 ;
(3) 矩阵的混合存取
与向量类似，对矩阵一个以上的元素进行读取或复制操作，称为混合存取(swizzling)。
float4x4 worldMatrix= float4({0 ,0 ,0 ,0} ,{1 ,1 ,1 ,1} ,{2 ,2 ,2 ,2} ,{3 ,3 ,3 ,3}) ;
float4x4 tempMatrix ;
tempMatrix._m00_m11 = worldMatrix._m00_m11 ;
tempMatrix._m00_m11 = worldMatrix._m13_m33 ;
tempMatrix._11_22_33 = worldMatrix._11_22_33 ;
tempMatrix._11_22_33 = worldMatrix._24_23_22 ;
不正确的赋值
tempMatrix._11_m23 = worldMatrix._11_12 ; // 两种基准方式混用
tempMatrix._m00_m00 = worldMatrix.m_00_m11 ; // 不可在一次赋值对一个元素进行两次赋值
(4) 矩阵的数组存取方式
矩阵也可以使用类似访问数组的方式对其进行访问，此时基准为0，不是1.
4X4矩阵，可通过如下索引来访问其中的每个元素
[0][0], [0][1] , [0][2], [0][3]
[1][0], [1][1], [1][2], [1][3]
[2][0], [2][1], [2][2], [2][3],
[3][0], [3][1], [3][2], [3][3],
赋值
float2x2 fMatrix ={1.0f ,1.1.f ,2.0f ,2.1f} ;
float temp ;
temp = fMatrix[0][0] ;
temp = fMatrix[0][1] ;
数组存取方式可以用来存取多元素的向量
float2 temp ;
float2x2 fMatrix ;
temp = fMatrix[0] ; // 将矩阵fMatrix的第一行赋值给向量temp
(5) 矩阵的存放顺序
矩阵中数据的存放方式具体采用行主序还是列主序可以在编译的指定。
使用语句 #pragma pack_matrix(row_major) 或 #pragma pack_matrix(col_major)指定。
列主序效率高于行主序
(6) 矩阵的数学运算
HLSL中，矩阵的数学原酸也是逐元素进行的
float3x3 mat1 ,mat2 ；
float3x3 mat3 = mat1 * mat2 ;
其结果mat3中的值，是两个矩阵mat1和mat2的元素逐个进行相乘后的值
mat3.m00 = mat1._m00 * mat._m00 ;
(7) 复杂数据类型
HLSL支持复杂的数据类型来处理类似采样器(sampler)、结构体(structure)、渲染器(shader)这样的对象
采样器