HLSL语言基础

// Hello HLSL.

/*********************************
 This is my first HLSL.
 Let's take a look.
*********************************/

#define TEST1  // 定义为空的宏

#ifdef TEST1  // 条件成立
#endif

#define TEST1 1 // 定义TEST1宏为1  注：可以不用先undef TEST1宏 但会报warning X1519: 'TEST1' : macro redefinition

#undef TEST1  // 取消TEST1宏

#if TEST1  // 条件不成立
#endif

#ifndef TEST1  // 条件成立
#endif

#define TEST1 -1  // 定义为int的宏

#define TEST2 // 定义为空的宏

#if TEST1 && defined(TEST2) // 条件成立
#endif

#define TEST3 true // 定义为bool的宏

#if TEST3  // 条件不成立
#endif

#if !TEST3  // 条件成立
#endif

#if TEST3==true  // 条件成立
#endif

#if !defined(TEST0) && TEST1 && defined(TEST2) // 条件成立
#endif

#define TEST4 100  // 定义为int的宏

#if TEST4  // 条件成立
#endif

#if TEST4 > 150
#elif (TEST4 > 120) || TEST1 // 进入elif分支
#endif

#if TEST4 > 160
#else // 进入else分支
#define XX2 1
#endif

#if !TEST4
#elif (TEST4 > 110)
#else // 进入else分支
#endif

#define TEST5 2.0  // 定义为float的宏

//#if TEST5  //float不能进行条件判断  编译失败
//#endif

//#if TEST5>0.0  //float不能进行条件判断  编译失败
//#endif

#define TEST1 100  // 定义TEST1宏为100

#ifdef TEST1  // 条件成立
#undef TEST1   // 取消TEST1宏的定义
#endif

#if !defined(TEST1) // 条件成立
#endif

#define SQUARE(a) ((a)*(a))

#define MAX(a,b) \
    (((a) > (b)) ? (a) : (b)) // 宏必须在一行写完，多行写时必须带上 \行连接符，但要注意\后不要有空格，否则会编译失败

#define MERGE(a, b) a##b // ## 字符拼接符

#if __LINE__==10  // 判断当前行号是否为10
#endif

#if __FILE__==0  // 条件成立  __FILE__始终为0
#endif

#line 116 // 指定下一行的行号为116
#if __LINE__==116  // 条件成立
#endif

#line 200 "test.hlsl"  // 指定下一行的行号为200，当前文件名为test.hlsl
#if __FILE__==0  // 条件成立   __FILE__始终为0
#endif

// test.hlsl(204,2): error: This is an error!
#error This is an error! 

// E:\ModenD3D\HLSL-Development-Cookbook\book_sample\Chpater 1 - Forward Light\Ambient Light\ForwardLight.hlsl(40,2): error: This is an error! 
#error This is an error!

#pragma warning( disable : 1519; once : 3205; error : 3206 ) // 忽略1519 warning，只报一次3205 warning，3206 warning视为error

#define TEST1  // 定义为空的宏
#define TEST1 1 // 定义TEST1宏为1  注：可以不用先undef TEST1宏 但会报warning X1519: 'TEST1' : macro redefinition

#pragma message("Hello HLSL.") //Hello HLSL.

#pragma pack_matrix( column_major ) // 将uniform参数的matrix设置成列主序（缺省）  注1：列主序生成的指令数更少，因此其效率比行主序的效率要高  注2：构造matrix时不受#pragma pack_matrix影响，始终为行主序
#pragma pack_matrix( row_major ) // 将uniform参数的matrix设置成行主序

#error This is an error! // hlsl中出现error时，才会打印pragma message和warning信息

#include "common.hlsl" // 引用其他的hlsl文件

typedef vector<float, 3> POINT;
typedef const float CFLOAT;

POINT pt;
CFLOAT cf1;

int n1 = 5 % 3;  // 取模即求余数，结果为2
float f1 = 3.3 % 1.6; // 3.3-(int)(3.3/1.6)*1.6 = 3.3-2*1.6 = 0.1
float f2 = -3.3 % 1.6; // -3.3-(int)(-3.3/1.6)*1.6 = -3.3-(-2*1.6) = -0.1

[flatten]
if (x)
{
    x = sqrt(x);
}

times = 4;
sum = times;
[unroll]
while (times--)
{
    sum += times;
}

times = 4;
sum = times;

sum += 3;
sum += 2;
sum += 1;

/****************************** C++ ******************************/
struct VS_CONSTANT_BUFFER
{
    D3DXMATRIX mWorldViewProj;

    D3DXVECTOR4 vSomeVectorThatMayBeNeededByASpecificShader;
    float fSomeFloatThatMayBeNeededByASpecificShader;
    
    float fTime;

    float fSomeFloatThatMayBeNeededByASpecificShader2;
    float fSomeFloatThatMayBeNeededByASpecificShader3;
};


/***************************** HLSL *****************************/
// 在cb0中，第一个 mWorldViewProj : packoffset(c0)表示将会在这个cbuffer中的c0位置开始存储 mWorldViewProj,共使用c0,c1,c2,c3
// 由于D3DXVECTOR4 vSomeVectorThatMayBeNeededByASpecificShader占据了c4，float fSomeFloatThatMayBeNeededByASpecificShader占据了c5.x，所以float fTime就是c5.y了

// 在C++代码层中，D3DXMATRIX矩阵是行矩阵，但当矩阵从C++传递给HLSL时，HLSL默认是列矩阵的，因此传递前要进行了一次转置。如果希望不发生转置操作的话，则需要添加修饰关键字row_major 
cbuffer cb0
{
    row_major float4x4 mWorldViewProj : packoffset(c0);

    float fTime : packoffset(c5.y);
};

cbuffer ConstantBuffer : register(b0)
{
    float4x4 g_WorldViewProj;
}


void VS_Main(
    in float4 inPos : POSITION,         // 绑定变量到输入装配器
    in uint VID : SV_VertexID,          // 绑定变量到系统生成值
    out float4 outPos : SV_Position)    // 告诉管线将该值解释为输出的顶点位置
{
    outPos = mul(inPos, g_WorldViewProj);
}

cbuffer ConstantBuffer : register(b0)
{
    float4x4 g_WorldViewProj;
}

struct VertexIn
{
    float4 inPos : POSITION;    // 源自输入装配器
    uint VID : SV_VertexID;        // 源自系统生成值
};

float4 VS_Main(VertexIn vIn) : SV_Position
{
    return mul(vIn.inPos, g_WorldViewProj);
}

tbuffer mytb : register(t0)
{
    float weight[256];        // 可以从CPU更新，只读
}

Buffer<float4> g_Buffer : register(t0);

RWBuffer<float4> g_RWBuffer : register(u0);

ConsumeStructuredBuffer<float3> g_VertexIn : register(u0);

ByteAddressBuffer g_ByteAddressBuffer : register(t0);

RWByteAddressBuffer g_RWByteAddressBuffer : register(u0);

// 布尔型
bool b1 = true;
bool b2 = 10; // b2=true

// 32位有符号整型
int n1 = 10;
int n2 = { -25 };
int n3 = 0;
int n4 = 0.9; // 取整数部分  n4=0
int n5 = 3L; // n5=3
int n6 = 0x14; // 16进制 n6=20
int n7 = 027; // 8进制 n7=23
int n8 = b1; // n8=1

// 32位无符号整型
uint u1 = 0;
uint u2 = 1u;
uint u3 = 100L;
uint u4 = 1.5;// 取整数部分  u4=1
uint u5 = -3.2;// 赋值为负数时  u5=0
uint u6 = b1;// u6=1

// dword类型与uint类型等价
dword dw1 = 150;
dword dw2 = 0.9;// 取整数部分  dw2=0
dword dw3 = -2.8f;// 赋值为负数时  dw3=0

// 64位双精度浮点型
double d1 = 200UL;
double d2 = dw1;
double d3 = 20.8f;
double d4 = 320.5;

// 32位单精度浮点型
float f1 = -250.6;
float f2 = 130.0f;
float f3 = d3;

// 16位单精度浮点型
half h1 = 1.0f;
half h2 = n6; // h2=20
half h3 = d4; // h3=320.5
half h4 = f2; // h4=130.0f
half h5 = f1 + d1; // h5=-50.6

// 基础类型强制转换
bool b3 = bool(n3); // b3=false  支持c类型的转换方式
int n9 = int(f1); // n9=-250  支持c类型的转换方式
uint u7 = (uint)f1; // u7=0
uint u8 = (uint)d3; // u8=20

float fa1[5]; // fa1 = {0.0, 0.0, 0.0, 0.0, 0.0}
int ia1[3] = { 1 ,2 ,3 };
uint ua1[2][3] = { {2, 3, 5},{4, 8, 7} };
vector va1[2] = { {0.1, 0.2, 0.13, 0.0}, {1.0, 0.0, 2.0, 1.0} };
float1x2 ma1[2] = { {2.0, 4.0}, {0.5, 0.6} };

struct base { float param; };

struct light : base // 可从另外一个结构体上继承
{
    vector color;
    float3 position;

    //light(){} // 与C语言一样，不允许有构造函数
    //~light(){} // 与C语言一样，不允许有析构函数

    void test()
    {
        param = 0.5;
        color.x = 0.2;
    }
};

//base s1 = base(2.5); //编译错误 error X3037: constructors only defined for numeric base types
//light s2 = light(2.1, vector(1.0, 1.0, 0.0, 1.0), float3(10.0, 10.0, 0.0));//编译错误 error X3037: constructors only defined for numeric base types
light s3, s4;
//if (s3 == s4) {}// 结构体不能直接比较  编译错误 error X3020 : type mismatch

s3.test();

// 向量 vector为4维float类型向量
vector v1 = { 0.0, 1.0, 0.0, 0.0 };
vector v2; // v2 = { 0.0, 0.0, 0.0, 0.0 }
v2[0] = 1.0; // v2 = { 1.0, 0.0, 0.0, 0.0 }
v2.z = 1.0; // v2 = { 1.0, 0.0, 1.0, 0.0 }
v2.g = 1.0; // v2 = { 1.0, 1.0, 1.0, 0.0 }

// 混合（swizzle）
vector v3 = v1.yzwx; // v3 = { 1.0, 0.0, 0.0, 0.0 } 等价于 v3.x=v1.y; v3.y=v1.z; v3.z=v1.w; v3.w=v1.x;
vector v4 = v1.rbga; // v4 = { 0.0, 0.0, 1.0, 0.0 }  等价于 v4.x=v1.r; v4.y=v1.b; v4.z=v1.g; v4.w=v1.a;
vector v5 = vector(0.5, 0.2, 1.0, 0.0); // v5 = { 0.5, 0.2, 1.0, 0.0 }  新构造方法
v5.xz = v1; // v5 = { 0.0, 0.2, 0.0, 0.0 }  只将v1的xz分量赋值给v5，等价于 v5.x=v1.x; v5.z=v1.z;

//vector v6 = vector(0.95); // 编译错误  error X3014: incorrect number of arguments to numeric-type constructor
vector v6 = (vector)0.95; // v6 = { 0.95, 0.95, 0.95, 0.95 }

vector<float, 4> v7 = v1; // vector<float, 4>即vector类型  v7 = { 0.0, 1.0, 0.0, 0.0 }

// 向量运算
vector v8 = { 0.2, -0.8, 0.3, 0.6 };
vector v9 = { 0.0, 0.5, 1.0, 0.2 };
vector v10 = v8 * 2; // v10 = {0.4, -1.6, 0.6, 1.2}
vector v11 = v8 + 0.6; // v11 = {0.8, -0.2, 0.9, 1.2}
vector v12 = v8 + v9; // v12 = { 0.2, -0.3, 1.3, 0.8 }
vector v13 = v8 * v9; // v13 = {0.0, -0.4, 0.3, 0.12}

// 逐分量进行比较
vector<bool, 4> v14 = (v8 > v9); // v14 = {true, false, false, true}

// 点乘(内积)
float ret1 = dot(v8, v9); // 0.2*0.0+(-0.8)*0.5+0.3*1.0+0.6*0.2 = 0.02
// 叉乘(外积)  3维向量特有
vector<float, 3> vf3Ret = cross(v8.xyz, v9.xyz); // vf3Ret.x=v8.y*v9.z-v8.z*v9.y = -0.8*1.0-0.3*0.5   = -0.95
                                                 // vf3Ret.y=v8.z*v9.x-v8.x*v9.z = 0.3*0.0-0.2*1.0    = -0.2
                                                 // vf3Ret.z=v8.x*v9.y-v8.y*v9.x = 0.2*0.5-(-0.8)*0.0 = 0.1

vector<int, 3> vi3a; // vi3a = {0, 0, 0}
vi3a.b = 10;  // vi3a = {0, 0, 10}

vector<bool, 2> vb2a; // vb2a = {false, false}
vb2a.x = true; // vb2a = {true, false}

// float4即vector
float4 vf4a; // vf4a = { 0.0, 0.0, 0.0, 0.0 }
vf4a = v2; // vf4a = { 1.0, 1.0, 1.0, 0.0 }

float1 vf1a = 0.75; // float3即vector<float,1> 即float类型
float f1 = vf1a; // f1为0.75
float f2 = vf1a.x; // f2为0.75
float f3 = vf1a.r; // f3为0.75

float2 vf2a = { 0.8, 0.9 }; // float2即vector<float,2>
float3 vf3a = { 0.2, 0.35, 0.5 }; // float3即vector<float,3>
float3 vf3b; // vf3b = { 0.0, 0.0, 0.0 }

//vf3b = vf2a; // error 编译错误  低维向量不允许赋值给高维向量
float2 vf2b = vf3a; // vf2b = { 0.2, 0.35 } 当N>n时，可裁剪降维后自动隐式转换   N --> n
vf3b = float3(vf2a, 1.0); // vf3b = { 0.8, 0.9, 1.0 }
vf3b = float3(0.3, vf2a); // vf3b = { 0.3, 0.8, 0.9 }
vf3b = float3(vf1a, vf2a); // vf3b = { 0.75, 0.8, 0.9 }
vf3b = v1;  // vf3b = { 0.0, 1.0, 0.0 };  高维向量可赋值给低维向量  后面的部分会被截断

float4 vf4b = { vf2a, vf2a }; // vf4b = { 0.8, 0.9, 0.8, 0.9 }
float4 vf4c = { 0.7, vf2a, 0.5 }; // vf4c = { 0.7, 0.8, 0.9, 0.5 }
float4 vf4d = { 0.7, vf3a }; // vf4d = { 0.7, 0.2, 0.35, 0.5 }

bool2 vb2b; // bool2即vector<bool,2>
int2 vi2a; // int2即vector<int,2>
uint2 vu2a; // uint2即vector<uint,2>
// dword2 vdw2a; // error 编译错误  不存在dword2类型
half2 vh2a; // half2即vector<half,2>
double2 vd2a; // double2即vector<double,2>
vf2a = vb2b;
vf2a = vi2a;
vf2a = vu2a;
vf2a = vh2a;
vf2a = vd2a;

float2 f2a = { 1.6, 1.8 };
float3 f3a = { 0.0, -1.0, 3.0 };
float2x2 m2x2a; // m2x2a = {0.0, 0.0, 0.0, 0.0}
float2x2 m2x2b = { 0.8, 0.6, 2.0, 0.9 }; // m2x2b = {0.8, 0.6, 2.0, 0.9}
                                         //          | 0.8  0.6 |
                                         //          | 2.0  0.9 |
float2x2 m2x2c = float2x2( f3a, 0.1 ); // m2x2c = {0.0, -1.0, 3.0, 0.1}
                                       //          | 0.0  -1.0 |
                                       //          | 3.0   0.1 |
//float2x2 m2x2d = float2x2(f2a, f3a);  // 编译出错  error X3014: incorrect number of arguments to numeric-type constructor
float2x2 m2x2e = float2x2(f2a, f3a.xz); // m2x2e = {1.6, 1.8, 0.0, 3.0}
                                        //          | 1.6  1.8 |
                                        //          | 0.0  3.0 |
//float2x2 m2x2f = float2x2(5.0); // 编译出错  error X3014: incorrect number of arguments to numeric-type constructor
float2x2 m2x2g = (float2x2)5.0; // m2x2g = {5.0, 5.0, 5.0, 5.0}
                                //          | 5.0  5.0 |
                                //          | 5.0  5.0 |

float2 f2b = m2x2b[0]; // 获取m2x2b的第1个行向量  f2b = {0.8  0.6}
float2 f2c = m2x2b[1]; // 获取m2x2b的第2个行向量  f2c = {2.0  0.9}

float f1 = m2x2b[0][1]; // 获取m2x2b的第1行第2列元素 f1 = 0.6
float f2 = m2x2b[0].y; // 获取m2x2b的第1行第2列元素 f2 = 0.6
float f3 = m2x2b[0].g; // 获取m2x2b的第1行第2列元素 f3 = 0.6
float f4 = m2x2b._m01; // 获取m2x2b的第1行第2列元素 f4 = 0.6
float f5 = m2x2b._12; // 获取m2x2b的第1行第2列元素 f5 = 0.6
float2 f2d = m2x2e._11_22 // 获取m2x2e的第1行第1列元素及第2行第2列元素 Swizzle f2d = {1.6  3.0}
m2x2e._12_21 = m2x2e._21_12; // 交换m2x2e[0][1]和m2x2e[1][0] Swizzle
                             // m2x2e = {1.6, 0.0, 1.8, 3.0}
                             //          | 1.6  0.0 |
                             //          | 1.8  3.0 |    
m2x2e._m00_m11 = m2x2e._m11_m00;    // 交换M[0][0]和M[1][1]     Swizzle                         
                             // m2x2e = {3.0, 0.0, 1.8, 1.6}
                             //          | 3.0  0.0 |
                             //          | 1.8  1.6 |
                             
float2x2 m2x2h = m2x2b + m2x2c; // m2x2h = {0.8, -0.4, 5.0, 1.0}
float2x2 m2x2i = m2x2b * m2x2c; // m2x2i = {0.0, -0.6, 6.0, 0.09}
float2x2 m2x2j = m2x2b + 0.2; // m2x2j = {1.0, 0.8, 2.2, 1.1}
float2x2 m2x2k = m2x2b * 2; // m2x2k = {1.6, 1.2, 4.0, 1.8}
//float2x2 m2x2l = f2a + m2x2b; // 编译错误  error X3020: type mismatch
//float2x2 m2x2m = f2a * m2x2b; // 编译错误  error X3020: type mismatch

float2x1 m2x1a = { 1.0, 0.2 }; // m2x1a = { 1.0, 0.2 }
                               //          | 1.0 |
                               //          | 0.2 |
float1x2 m1x2a = { 0.3, 1.0 }; // m1x2a = { 0.3, 1.0 }    
                               //         | 0.3  1.0 |
// 矩阵算术运算  M x N --> m x n   注：当M>m且N>n时，可裁剪降维后自动隐式转换
float2x1 m2x1b = f2a + m2x1a; // float2向量可与float2x1矩阵进行算术运算  
                              // m1x2b = { 2.6, 2.0 }    
                              //           | 2.6 |
                              //           | 2.0 |
float1x1 m1x1a = { 0.2 }; // | 0.2 |
float3x3 m3x3a = {0.1, 0.0, 0.2, 0.15, -0.1, 0.0, -0.2, 0.0, 0.3}; 
                   // | 0.1   0.0  0.2 |
                   // | 0.15 -0.1  0.0 |
                   // | -0.2  0.0  0.3 |
//float2x2 m2x2n = m2x2b + m2x1a; // 编译错误  error X3017: cannot implicitly convert from 'const float2x1' to 'float2x2'
float2x1 m2x1c = m2x2b + m2x1a; // m1x2c = { 1.8, 0.8 } 
float2x2 m2x2o = m2x2b + m1x1a; // m2x2o = {1.0, 0.8, 2.2, 1.1}  注：m1x1a退化为float
float2x2 m2x2p = m2x2b + m3x3a; // m2x2p = {0.9, 0.6, 2.15, 0.8}
//float3x3 m3x3b = m3x3a + m2x2b; // 编译错误 error X3017 : cannot implicitly convert from 'const float2x2' to 'float3x3'
//float3x3 m3x3c = m2x2b + m3x3a; // 编译错误 error X3017 : cannot implicitly convert from 'const float2x2' to 'float3x3'


// 矩阵-矩阵乘法
float1x1 m1x1b = mul(m1x2a, m2x1a); //                  | 1.0 |
                                    // | 0.3  1.0 | mul | 0.2 | = 0.5

float2x2 m2x2r = mul(m2x1a, m1x2a);//  | 1.0 |                    | 0.3  1.0 |
                                    // | 0.2 | mul | 0.3  1.0 | = | 0.06 0.2 |

// 矩阵右乘向量
float2x1 m2x1d = mul(m2x2b, f2a);  // f2a被当成列向量
                                   //  | 0.8  0.6 |     | 1.6 |   | 2.36 |
                                    // | 2.0  0.9 | mul | 1.8 | = | 4.82 |

// 矩阵左乘向量
float1x2 m1x2b = mul(f2a, m2x2b);  // f2a被当成行向量
                                   //                   | 0.8  0.6 | 
                                   //  | 1.6  1.8 | mul | 2.0  0.9 | = | 4.88 2.58 |

/****************************** C++ ******************************/
ID3D11ShaderResourceView*   g_pTexture1 = NULL;
ID3D11ShaderResourceView*   g_pTexture2 = NULL;
ID3D11SamplerState*         g_pSampLinear = NULL;
// PCF sampler state for shadow mapping
ID3D11SamplerState*         g_pPCFSamplerState = NULL;

// Create Shader Resouce View (Texture2D)
WCHAR str[MAX_PATH];
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"..\\Media\\Bokeh1.dds" ) );
V_RETURN( D3DX11CreateShaderResourceViewFromFile( g_pDevice, str, NULL, NULL, &g_pTexture1, NULL ) ); // ID3D11Device* g_pDevice;
V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"..\\Media\\Bokeh2.dds" ) );
V_RETURN( D3DX11CreateShaderResourceViewFromFile( g_pDevice, str, NULL, NULL, &g_pTexture2, NULL ) ); // ID3D11Device* g_pDevice;

// Set Shader Resources
ID3D11ShaderResourceView* arrViews[2] = { g_pTexture1, g_pTexture2};
pd3dImmediateContext->PSSetShaderResources(0, 2, arrViews);// ID3D11DeviceContext* pd3dImmediateContext

// --------------------------------------------------------------

// Create sampler
D3D11_SAMPLER_DESC samDesc;
ZeroMemory( &samDesc, sizeof(samDesc) );
samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samDesc.MaxAnisotropy = 1;
samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSampLinear ) );

// Create the PCF sampler state
D3D11_SAMPLER_DESC samDesc2;
ZeroMemory( &samDesc2, sizeof(samDesc2) );
samDesc2.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;
samDesc2.AddressU = samDesc2.AddressV = samDesc2.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
samDesc2.MaxAnisotropy = 1;
samDesc2.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
samDesc2.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( g_pDevice->CreateSamplerState( &samDesc2, &g_pPCFSamplerState ) );

// Set render resources
pd3dImmediateContext->PSSetSamplers( 0, 1, &g_pSampLinear ); // ID3D11DeviceContext* pd3dImmediateContext

// Set the shadowmapping PCF sampler
pd3dImmediateContext->PSSetSamplers( 2, 1, &g_pPCFSamplerState ); // ID3D11DeviceContext* pd3dImmediateContext


/***************************** HLSL *****************************/

/////////////////////////////////////////////////////////////////////////////
// Diffuse texture and linear sampler
/////////////////////////////////////////////////////////////////////////////
Texture2D    Diffuse1Texture : register( t0 );
Texture2D    Diffuse2Texture : register( t1 );
SamplerState LinearSampler : register( s0 );

SamplerComparisonState PCFSampler : register( s2 );

// sampler define in shader code
SamplerState MeshTextureSampler
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

float4 AmbientLightPS( VS_OUTPUT In ) : SV_TARGET0  // VS_OUTPUT In：VS的输出经过光栅化插值后，会作为输入传入PS
{ 
    // Sample the texture and convert to linear space
    float4 Diffuse1Color =  Diffuse1Texture.Sample( LinearSampler, In.UV );
    float4 Diffuse2Color =  Diffuse2Texture.Sample( LinearSampler, In.UV );
    
    // ... ...

    return float4((Diffuse1Color+Diffuse2Color).rgb, 1.0);
}

float square(float value) // 求平方
{
    return value * value;
}

void fuc1(const float value) // const参数不能在函数内部修改
{
    //value = 0.2; // assignment to const variable value  编译错误
}

void fuc2(out float value)  // value在函数内使用前必须先初始化；在函数内修改，对外可见
{
    value = 0.0; // 注：在函数内使用out参数之前，必须先初始化，否则会编译错误
    value += 0.5;
}

void fuc3(inout float value) // value的初始值从函数外传入；在函数内修改，对外可见
{
    value += 0.5;
}

int fun4(int n)  // 直接或间接调用fun4函数，会编译报错：recursive call to function
{
    if (n == 0 || n == 1)
    {
        return 1;
    }
    return fun4(n - 1) + fun4(n - 2);
}