unity shader 里的那些流程控制宏

// HLSL attributes
#if defined(UNITY_COMPILER_HLSL)
    #define UNITY_BRANCH    [branch]
    #define UNITY_FLATTEN   [flatten]
    #define UNITY_UNROLL    [unroll]
    #define UNITY_LOOP      [loop]
    #define UNITY_FASTOPT   [fastopt]
#else
    #define UNITY_BRANCH
    #define UNITY_FLATTEN
    #define UNITY_UNROLL
    #define UNITY_LOOP
    #define UNITY_FASTOPT
#endif

微软的 hlsl 官方文档：

if 语句 - Win32 apps | Microsoft Docs

for 语句 - Win32 apps | Microsoft Docs

while 语句 - Win32 apps | Microsoft Docs

可以结合着英文文档看，因为中文这边把 unroll 这关键字给翻译没了。。。

for Statement - Win32 apps | Microsoft Docs

[branch] （分支）可以特别说说，这个玩意的功能是，会创建 if 一侧的动态分支，然后先计算 if 的条件，再根据它的结果去往后面走。看着很美好，但是实际上很坑。我们来说说它的缺点：

1，因为它要等if的结果，所以会打乱执行顺序，破坏gpu的并行运算，在做一些大数据量运算时，就会拖后腿了

2，根据查到的说法，现在的 gpu 动态分支都需要6条指令，所以除非你 if 里的操作大于6条指令，否则你这么干就是亏的~~~ 意思就是判断的消耗比运算还高

3，而且这个东西吧，过度使用还容易报错

而 [flatten] （平展），是把 if else 的2侧都给算出来，可以理解为1个像素算2遍，然后再根据条件显示一头。

不过根据我的习惯来说，尽量避免写 if 就好了。step, saturate, lerp 这些方法都可以用来实现 if 的效果。

[unroll(100)]
for.......

展开一般就像是上面这么用，用来通知 gpu 去尝试展开这个循环。

所谓的展开，你就可以理解成，把 for {} 里的内容复制出来，搞成一条一条的，然后顺序执行，和贴代码是一个道理，只不过是编译器帮你贴了。

在实际使用时，我还碰到过因为 for 循环次数太大，报错提示我加。

加了这个指令后编译速度感人。。。可以去倒水上厕所了

[loop] 就是不展开循环了，用流式的方式执行

[fastopt] 也是不展开了，和 [loop] 类似，但是看官方的说法，可能连优化都不给搞了，但是编译速度就飞快了。

补上一个用 cg 语言写的，用来代替 shader 中 if 判断的 .cginc 文件，因为都是数学运算，所以就完全不会开动态分支了

/**
 * Cg语言运算符替代库 - 主要用于替代 if ，让 gpu 不产生分支运算
 */

#ifndef __OPERATOR_INSTEAD_FUNC__
#define __OPERATOR_INSTEAD_FUNC__


// 关系运算符 ============================================================
/**
 * \brief 关系运算符 ==
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_equal (in float Left, in float Right)
{
    float temp = sign(Left - Right);
    return 1.0 - abs(temp);
}

/**
 * \brief 关系运算符 !=
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_not_equal (in float Left, in float Right)
{
    float temp = sign(Left - Right);
    return abs(temp);
}

/**
 * \brief 关系运算符 >
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_greater (in float Left, in float Right)
{
    float temp = sign(Left - Right);
    return max(temp, 0.0);
}

/**
 * \brief 关系运算符 <
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_less (in float Left, in float Right)
{
    float temp = sign(Right - Left);
    return max(temp, 0.0);
}

/**
 * \brief 关系运算符 >=
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_greater_equal (in float Left, in float Right)
{
    float temp = if_less(Left, Right);
    return 1.0 - temp;
}

/**
 * \brief 关系运算符 <=
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_less_equal (in float Left, in float Right)
{
    float temp = if_greater(Left, Right);
    return 1.0 - temp;
}


// 逻辑运算符 ============================================================
/**
 * \brief 逻辑运算符 &&
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_and(in float Left, in float Right)
{
    return Left * Right;
}

/**
 * \brief 逻辑运算符 ||
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_or(in float Left, in float Right)
{
    return max(Left, Right);
    // or
    //return min(left + right, 1.0);
}

/**
 * \brief 逻辑运算符 ^
 * \param Left 
 * \param Right 
 * \return 结果与线性混合结合使用
 */
inline float if_xor(in float Left, in float Right)
{
    return (Left + Right) % 2.0;
}

/**
 * \brief 逻辑运算符 !
 * \param Value 
 * \return 结果与线性混合结合使用
 */
inline float if_not(in float Value)
{
    return 1.0 - Value;
}


/**
 * \brief 线性混合，等效于 lerp 方法\n 和运算符结合使用时，用 if 的结果来当 factor
 * \param Left 左侧值
 * \param Right 右侧值
 * \param Factor 线性混合系数
 * \return 根据 factor 返回 left 和 right 之间的值，\n factor=0 时返回 left，factor=1 时返回 right
 */
inline float line_mix (in float Left, in float Right, in float Factor)
{
    float temp = 1.0 - Factor;
    return Left * temp + Right * Factor;
}


#endif