OpenGL ES Shading Language 2.0 参考笔记

川长思鸟来 2022-06-01 00:23 171阅读 0赞

*这里只是一份简略的笔记,仅为方便参考而已,更详细的信息可以参考[这里][Link 1]*

## 类型(type) ##

### 标量类型(scalar type) ###

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void</td> 
   <td>无类型</td> 
   <td>void function(void);</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>bool</td> 
   <td>布尔类型</td> 
   <td>bool bValue = true;</td> 
   <td>不支持隐式类型转换,但是可以借助构造方式来进行类型转换,就像这样: bool bValue = bool(iValue);</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>整数类型</td> 
   <td>int iValue = 1;</td> 
   <td>不支持隐式类型转换,但是可以借助构造方式来进行类型转换,就像这样: int iValue = int(bValue);</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>浮点类型</td> 
   <td>float fValue = 1.0;</td> 
   <td>不支持隐式类型转换,但是可以借助构造方式来进行类型转换,就像这样: float fValue = float(iValue);</td> 
  </tr> 
 </tbody> 
</table>

### 向量类型(vector type) ###

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>bvec2</td> 
   <td>2维(2分量)布尔向量</td> 
   <td>bvec2 bVec2 = bvec2(true, true);</td> 
   <td><br>1. 可以使用标量类型对向量的各个分量分别进行初始化<br>2. 如果初始化参数是单个标量,则向量的各个分量都初始化为该标量<br>3.如果使用高维向量初始化低维向量,则低维向量的各个分量分别使用高维向量中对应的分量进行初始化 例如 <br><strong>bvec2 bVec2 = bvec2(bVec3);</strong> <br>等价于 <br><strong>bvec2 bVec2 = bvec2(bVec3.x, bVec3.y);</strong><br>4. 使用低维向量初始化高维向量是不允许的,但是可以使用低维向量与(或)标量类型组合的方式来初始化高维向量,但是组合对应的参数数量需要至少为高维向量的分量个数. 例如 <br><strong>vec3 bVec3 = bvec3(bVec2, bValue);<br>vec3 bVec3 = bvec3(bVec2.x, bVec2.y, bValue);</strong><br>5. 可以使用向量的构造方式来进行不同向量类型间的转化,其中向量的各个分量会自动进行相应的类型转换 例如 <br><strong>bvec2 bVec2 = bvec2(iVec2);</strong></td> 
  </tr> 
  <tr> 
   <td>bvec3</td> 
   <td>3维(3分量)布尔向量</td> 
   <td>bvec3 bVec3 = bvec3(true, true, true);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>bvec4</td> 
   <td>4维(4分量)布尔向量</td> 
   <td>bvec4 bVec4 = bvec4(true, true, true, true);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>ivec2</td> 
   <td>2维(2分量)整数向量</td> 
   <td>ivec2 iVec2 = ivec2(1, 1);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>ivec3</td> 
   <td>3维(3分量)整数向量</td> 
   <td>ivec3 iVec3 = ivec3(1, 1, 1);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>ivec4</td> 
   <td>4维(4分量)整数向量</td> 
   <td>ivec4 iVec4 = ivec4(1, 1, 1, 1);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>vec2</td> 
   <td>2维(2分量)浮点向量</td> 
   <td>vec2 fVec2 = vec2(1.0, 1.0);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>vec3</td> 
   <td>3维(3分量)浮点向量</td> 
   <td>vec3 fVec3 = vec3(1.0, 1.0, 1.0);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>vec4</td> 
   <td>4维(4分量)浮点向量</td> 
   <td>vec4 fVec4 = vec4(1.0, 1.0, 1.0, 1.0);</td> 
   <td>同上</td> 
  </tr> 
 </tbody> 
</table>

### 矩阵类型(matrix type) ###

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>mat2</td> 
   <td>2x2浮点矩阵</td> 
   <td>mat2 aMat2 = mat2(1.0, 0.0, // first column<br>0.0, 1.0); // second column<br>mat2 bMat2 = mat2(1.0);<br>mat2 cMat2 = mat2(aVec2, bVec2);<br>mat2 dMat2 = mat2(aVec3, aFloat);</td> 
   <td><br>1. 可以使用标量类型初始化矩阵的各个元素,矩阵按列顺序分别进行对应元素的初始化<br>2. 如果初始化参数是单个标量,则矩阵使用该标量初始化主对角线元素(<strong>注意,不是所有元素</strong>)<br>3. 可以使用向量与(或)标量类型组合的方式来初始化矩阵,但是组合对应的参数数量需要至少为矩阵的元素个数<br>4. 使用[col_index]可以访问矩阵的列向量,使用[col_index][row_index]可以访问矩阵的元素</td> 
  </tr> 
  <tr> 
   <td>mat3</td> 
   <td>3x3浮点矩阵</td> 
   <td>mat3 aMat3 = mat3(1.0, 0.0, 0.0, // 1. column<br>0.0, 1.0, 0.0, // 2. column<br>0.0, 0.0, 1.0); // 3. column<br>mat3 bMat3 = mat3(1.0);<br>mat3 cMat3 = mat3(aVec3, bVec3, cVec3);<br>mat3 dMat3 = mat3(aVec4, aVec3, bVec4, aFloat);</td> 
   <td>同上</td> 
  </tr> 
  <tr> 
   <td>mat4</td> 
   <td>4x4浮点矩阵</td> 
   <td>mat4 aMat4 = mat4(1.0, 0.0, 0.0, 0.0, // 1. column<br>0.0, 1.0, 0.0, 0.0, // 2. column<br>0.0, 0.0, 1.0, 0.0, // 3. column<br>0.0, 0.0, 0.0, 1.0); // 4. column<br>mat4 bMat4 = mat4(1.0);<br>mat4 cMat4 = mat4(aVec4, bVec4, cVec4, dVec4);<br>mat4 dMat4 = mat4(aVec4, aVec3, bVec4, cVec4, aFloat);</td> 
   <td>同上</td> 
  </tr> 
 </tbody> 
</table>

### 贴图类型(texture type) ###

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sampler2D</td> 
   <td>2维贴图</td> 
   <td>uniform sampler2D texture;</td> 
   <td>需要声明为 uniform(<a rel="nofollow">限定符参考</a>)</td> 
  </tr> 
  <tr> 
   <td>samplerCube</td> 
   <td>立方体贴图</td> 
   <td>uniform samplerCube texture;</td> 
   <td>需要声明为 uniform(<a rel="nofollow">限定符参考</a>)</td> 
  </tr> 
 </tbody> 
</table>

### 结构(struct) ###

1.  结构可以组合使用上面所提到的标准类型
2.  结构可以包含数组或者结构
3.  可以使用构造方式初始化结构,但初始化参数类型必须与结构定义类型一一对应
4.  结构中的元素可以使用点号(.)进行访问

**声明**  
struct matStruct \{  
vec4 ambientColor;  
vec4 diffuseColor;  
vec4 specularColor;  
float specularExponent;  
\};

**构造**  
newMaterial = matStruct(vec4(0.1, 0.1, 0.1, 1.0),  
vec4(1.0, 0.0, 0.0, 1.0),  
vec4(0.7, 0.7, 0.7, 1.0),  
50.0);

**访问**  
vec4 ambientColor = newMaterial.ambientColor;  
vec4 diffuseColor = newMaterial.diffuseColor;  
vec4 specularColor = newMaterial.specularColor;  
float specularExponent = newMaterial.specularExponent;

### 数组(array) ###

1.  数组可以包含标准类型及结构类型
2.  数组声明时不能就地初始化
3.  数组需要以逐个元素的方式进行初始化

int newIntArray\[9\];  
vec3 newVec3Array\[3\];

newIntArray\[0\] = 5;  
newVec3Array\[1\] = vec3(1.0, 1.0, 1.0);

int newInt = newIntArray\[0\];  
vec3 newVec3 = newVec3Array\[1\];

## 限定符(qualifier) ##

### 存储限定符(storage qualifier) ###

<table> 
 <thead> 
  <tr> 
   <th>限定符</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>const</td> 
   <td>常量限定符</td> 
   <td>const float PI = 3.1415926;</td> 
   <td><br>1. 编译时常量<br>2. 只读函数参数</td> 
  </tr> 
  <tr> 
   <td>attribute</td> 
   <td>-</td> 
   <td>attribute vec4 a_position;</td> 
   <td><br>1. 一般用于限定 OpenGL ES 环境向 vertex shader 传送顶点的各个属性,譬如位置,朝向,顶点贴图坐标等等<br>2. 限定的数据不可更改<br>3. 限定的数据 vertex shader 可见, fragment shader 不可见<br>4. 只可以限定浮点类型的数据(浮点标量,浮点向量,(浮点)矩阵),<strong>不能限定浮点类型数组</strong><br>5. 需要在运行shader前加载好相应的限定数据</td> 
  </tr> 
  <tr> 
   <td>uniform</td> 
   <td>-</td> 
   <td>uniform vec2 u_resolution;</td> 
   <td><br>1. 一般用于限定一次渲染流程中不会改变的属性,譬如投影矩阵,光源位置,材质颜色等等<br>2. 限定的数据不可更改<br>3. 限定的数据 vertex shader 和 fragment shader 都可见,需要保证定义唯一<br>4. 需要在运行shader前加载好相应的限定数据</td> 
  </tr> 
  <tr> 
   <td>varying</td> 
   <td>-</td> 
   <td>varying vec2 v_texCoord;</td> 
   <td><br>1. 一般用于限定在 vertex shader 中进行计算并需要向 fragment shader 传递的数据<br>2. 限定的数据会首先由 vertex shader 进行初始化计算并经过光栅化阶段的插值再传递给 fragment shader<br>3. 限定的数据 vertex shader 和 fragment shader 都可见,需要保证定义唯一<br>4. 只可以限定浮点类型的数据(浮点标量,浮点向量,(浮点)矩阵以及包含这些类型的数组)</td> 
  </tr> 
 </tbody> 
</table>

### 精度限定符(precision qualifier) ###

<table> 
 <thead> 
  <tr> 
   <th>限定符</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>highp</td> 
   <td>高精度限定符</td> 
   <td>uniform highp vec3 lightDirection;</td> 
   <td><br>1. 用于限定某个变量使用定义类型的最高精度<br>2. 只可用于限定整型标量,整型向量,浮点标量,浮点向量及(浮点)矩阵<br>3. 在 vertex shader 中精度限定符是可选的,默认使用 highp,即最高精度<br>4. 在 fragment shader 中精度限定符是必选的,除非你定义了相应类型的默认精度(使用<a rel="nofollow">precision限定符</a>)<br>5. 精度的具体标识范围由具体的 OpenGL ES 实现决定,一般来讲,使用低精度可以提高渲染效率但是也会降低渲染质量</td> 
  </tr> 
  <tr> 
   <td>mediump</td> 
   <td>中精度限定符</td> 
   <td>varying mediump vec2 textureCoordinate;</td> 
   <td><br>1. 用于限定某个变量使用定义类型的中等精度<br>2. 只可用于限定整型标量,整型向量,浮点标量,浮点向量及(浮点)矩阵<br>3. 在 vertex shader 中精度限定符是可选的,默认使用 highp,即最高精度<br>4. 在 fragment shader 中精度限定符是必选的,除非你定义了相应类型的默认精度(使用<a rel="nofollow">precision限定符</a>)</td> 
  </tr> 
  <tr> 
   <td>lowp</td> 
   <td>低精度限定符</td> 
   <td>varying lowp vec4 colorVarying;</td> 
   <td><br>1. 用于限定某个变量使用定义类型的低等精度<br>2. 只可用于限定整型标量,整型向量,浮点标量,浮点向量及(浮点)矩阵<br>3. 在 vertex shader 中精度限定符是可选的,默认使用 highp,即最高精度<br>4. 在 fragment shader 中精度限定符是必选的,除非你定义了相应类型的默认精度(使用<a rel="nofollow">precision限定符</a>)</td> 
  </tr> 
  <tr> 
   <td><span>precision</span></td> 
   <td>默认精度限定符</td> 
   <td>precision highp float;</td> 
   <td><br>1. 用于限定某种类型的默认精度<br>2. 只可用于限定整型标量,整型向量,浮点标量,浮点向量及(浮点)矩阵<br>3. 在 vertex shader 中默认精度是 highp,即最高精度<br>4. 在 fragment shader 中精度限定符是必选的,除非你定义了相应类型的默认精度</td> 
  </tr> 
 </tbody> 
</table>

### 参数限定符(parameter qualifier) ###

<table> 
 <thead> 
  <tr> 
   <th>限定符</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>in</td> 
   <td>只读参数限定符</td> 
   <td>int newFunction(in bvec4 aBvec4, // read-only <br>out vec3 aVec3, // write-only<br>inout int aInt); // read-write</td> 
   <td>函数参数的默认限定符即为 in ,即函数参数默认都是只读的</td> 
  </tr> 
  <tr> 
   <td>out</td> 
   <td>只写参数限定符</td> 
   <td>int newFunction(in bvec4 aBvec4, // read-only <br>out vec3 aVec3, // write-only<br>inout int aInt); // read-write</td> 
   <td><br>1. 函数参数会以引用方式传递<br>2. 函数参数只可写不可读</td> 
  </tr> 
  <tr> 
   <td>inout</td> 
   <td>读写参数限定符</td> 
   <td>int newFunction(in bvec4 aBvec4, // read-only <br>out vec3 aVec3, // write-only<br>inout int aInt); // read-write</td> 
   <td><br>1. 函数参数会以引用方式传递<br>2. 函数参数可读可写</td> 
  </tr> 
 </tbody> 
</table>

## 内建的变量与常量(built-in variables and constants) ##

### 顶点着色器特殊输出变量(special output variables of the vertex shader) ###

<table> 
 <thead> 
  <tr> 
   <th>变量名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>gl_Position</td> 
   <td>顶点位置</td> 
   <td>highp vec4 gl_Position;</td> 
   <td><br>1. vertex shader 中必须为 gl_Position 赋值<br>2. gl_Position 需要变换到裁剪空间中</td> 
  </tr> 
  <tr> 
   <td>gl_PointSize</td> 
   <td>点大小</td> 
   <td>mediump float gl_PointSize;</td> 
   <td><br>1. 数值大小为点半径的像素大小<br>2. 点实际使用quad渲染<br>3. 渲染图元为点(GL_POINTS)时才会生效</td> 
  </tr> 
 </tbody> 
</table>

### 片段着色器特殊输入变量(special input variables of the fragment shader) ###

<table> 
 <thead> 
  <tr> 
   <th>变量名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>gl_FragCoord</td> 
   <td>片段坐标</td> 
   <td>mediump vec4 gl_FragCoord;</td> 
   <td><br>1. 只读变量<br>2. 定义于窗口坐标空间中,默认左下角为窗口坐标原点</td> 
  </tr> 
  <tr> 
   <td>gl_FrontFacing</td> 
   <td>片段朝向</td> 
   <td>bool gl_FrontFacing;</td> 
   <td><br>1. 只读变量<br>2. 标识片段是否属于正朝向图元(三角形图元)</td> 
  </tr> 
  <tr> 
   <td>gl_PointCoord</td> 
   <td>点坐标</td> 
   <td>mediump vec2 gl_PointCoord;</td> 
   <td><br>1. 只读变量<br>2. 渲染图元为点(GL_POINTS)时才可访问<br>3. 片元位于点图元的归一化位置,默认点图元左上角为归一化空间原点(gl_PointCoord 分量范围为(0, 1))</td> 
  </tr> 
 </tbody> 
</table>

### 片段着色器特殊输出变量(special output variables of the fragment shader) ###

<table> 
 <thead> 
  <tr> 
   <th>变量名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>gl_FragColor</td> 
   <td>片段颜色</td> 
   <td>mediump vec4 gl_FragColor;</td> 
   <td><br>1. fragment shader 中必须为 gl_FragColor 赋值<br>2. gl_FragColor 定义于 RGBA 颜色空间中</td> 
  </tr> 
 </tbody> 
</table>

### 顶点着色器内建常量(built-in constants of vertex shader) ###

<table> 
 <thead> 
  <tr> 
   <th>常量名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>gl_MaxVertexAttribs</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxVertexAttribs;</td> 
   <td><br>1. vertex shader 中 attribute 限定数据的最大个数(单位最大为vec4大小)<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 8</td> 
  </tr> 
  <tr> 
   <td>gl_MaxVertexUniformVectors</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxVertexUniformVectors;</td> 
   <td><br>1. vertex shader 中 uniform 限定数据的最大个数(单位最大为vec4大小)<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 128</td> 
  </tr> 
  <tr> 
   <td>gl_MaxVaryingVectors</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxVaryingVectors;</td> 
   <td><br>1. vertex shader 和 fragment shader 中 varying 限定数据的最大个数(单位最大为vec4大小)<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 8</td> 
  </tr> 
  <tr> 
   <td>gl_MaxVertexTextureImageUnits</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxVertexTextureImageUnits;</td> 
   <td><br>1. vertex shader 中可以使用的最大贴图数量<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 0, 即在 vertex shader 中无法访问纹理</td> 
  </tr> 
  <tr> 
   <td>gl_MaxCombinedTextureImageUnits</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxCombinedTextureImageUnits;</td> 
   <td><br>1. vertex shader 或者 fragment shader 中可以使用的最大贴图数量<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 8</td> 
  </tr> 
 </tbody> 
</table>

### 片段着色器内建常量(built-in constants of fragment shader) ###

<table> 
 <thead> 
  <tr> 
   <th>常量名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>gl_MaxTextureImageUnits</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxTextureImageUnits;</td> 
   <td><br>1. fragment shader 中可以使用的最大贴图数量<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 8</td> 
  </tr> 
  <tr> 
   <td>gl_MaxFragmentUniformVectors</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxFragmentUniformVectors;</td> 
   <td><br>1. fragment shader 中 uniform 限定数据的最大个数(单位最大为vec4大小)<br>2. 实际大小由 OpenGL ES 实现决定, 至少为 16</td> 
  </tr> 
  <tr> 
   <td>gl_MaxDrawBuffers</td> 
   <td>-</td> 
   <td>const mediump int gl_MaxDrawBuffers;</td> 
   <td><br>1. 最大的可用渲染缓存数量<br>2. 当前大小固定为 1</td> 
  </tr> 
 </tbody> 
</table>

## 语法声明(statements) ##

基本与 C 无异,简单列几点:

### 循环(loop) ###

for(;;) \{\} 示例 for(int i = 0; i <= 99; i++) \{ aFunction(); \}

while() \{\} 示例 while(i <= 99) \{ aFunction(); \}

do \{\} while(); 示例 do \{ aFunction(); \} while(i <= 99);

循环中可以使用 continue(终止单遍循环) 和 break(终止整个循环)

### 条件(condition) ###

if() \{\} 示例 if(i != 0) \{ aFunction(); \}

if() \{\} else \{\} 示例 if(i != 0) \{ aFunction(); \} else \{ bFunction(); \}

### 退出(exit) ###

可以使用 return; 退出无返回的函数

可以使用 return aValue; 退出对应返回值类型的函数

在 fragment shader 中可以使用 discard; 中断 fragment shader 的运行,对应的片元也不会被渲染

### 起始(start) ###

main 函数为 vertex shader 和 fragment shader 的入口函数,没有参数,也没有返回类型

void main(void) \{\}

## 内建函数(built-in functions) ##

### 角度与三角函数(angle and trigonometry functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>radians</td> 
   <td>角度转弧度</td> 
   <td>float radians(float degrees) <br>vec2 radians(vec2 degrees) <br>vec3 radians(vec3 degrees) <br>vec4 radians(vec4 degrees)</td> 
   <td>参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>degrees</td> 
   <td>弧度转角度</td> 
   <td>float degrees(float radians) <br>vec2 degrees(vec2 radians) <br>vec3 degrees(vec3 radians) <br>vec4 degrees(vec4 radians)</td> 
   <td>参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>sin</td> 
   <td>正弦函数</td> 
   <td>float sin(float angle) <br>vec2 sin(vec2 angle) <br>vec3 sin(vec3 angle) <br>vec4 sin(vec4 angle)</td> 
   <td><br>1. 参数为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>cos</td> 
   <td>余弦函数</td> 
   <td>float cos(float angle) <br>vec2 cos(vec2 angle) <br>vec3 cos(vec3 angle) <br>vec4 cos(vec4 angle)</td> 
   <td><br>1. 参数为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>tan</td> 
   <td>正切函数</td> 
   <td>float tan(float angle) <br>vec2 tan(vec2 angle) <br>vec3 tan(vec3 angle) <br>vec4 tan(vec4 angle)</td> 
   <td><br>1. 参数为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>asin</td> 
   <td>反正弦函数</td> 
   <td>float asin(float x) <br>vec2 asin(vec2 x) <br>vec3 asin(vec3 x) <br>vec4 asin(vec4 x)</td> 
   <td><br>1. 返回值为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>acos</td> 
   <td>反余弦函数</td> 
   <td>float acos(float x) <br>vec2 acos(vec2 x) <br>vec3 acos(vec3 x) <br>vec4 acos(vec4 x)</td> 
   <td><br>1. 返回值为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>atan</td> 
   <td>反正切函数</td> 
   <td>float atan(float y_over_x) <br>vec2 atan(vec2 y_over_x) <br>vec3 atan(vec3 y_over_x) <br>vec4 atan(vec4 y_over_x)<br>float atan(float y, float x) <br>vec2 atan(vec2 y, vec2 x) <br>vec3 atan(vec3 y, vec3 x)<br>vec4 atan(vec4 y, vec4 x)</td> 
   <td><br>1. 返回值为弧度 <br>2. 参数类型可以为浮点标量或者浮点向量 <br>3. 注意该函数具有两参数版本,等价于C语言中atan2函数</td> 
  </tr> 
 </tbody> 
</table>

### 指数函数(exponential functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pow</td> 
   <td>-</td> 
   <td>float pow(float x, float y) <br>vec2 pow(vec2 x, vec2 y) <br>vec3 pow(vec3 x, vec3 y) <br>vec4 pow(vec4 x, vec4 y)</td> 
   <td><br>1. 返回 x^y <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>exp</td> 
   <td>-</td> 
   <td>float exp(float x) <br>vec2 exp(vec2 x) <br>vec3 exp(vec3 x) <br>vec4 exp(vec4 x)</td> 
   <td><br>1. 返回 e^x <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>log</td> 
   <td>-</td> 
   <td>float log(float x) <br>vec2 log(vec2 x) <br>vec3 log(vec3 x) <br>vec4 log(vec4 x)</td> 
   <td><br>1. 返回 loge(x),即以e为底的对数函数 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>exp2</td> 
   <td>-</td> 
   <td>float exp2(float x) <br>vec2 exp2(vec2 x) <br>vec3 exp2(vec3 x) <br>vec4 exp2(vec4 x)</td> 
   <td><br>1. 返回 2^x <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>log2</td> 
   <td>-</td> 
   <td>float log2(float x) <br>vec2 log2(vec2 x) <br>vec3 log2(vec3 x) <br>vec4 log2(vec4 x)</td> 
   <td><br>1. 返回 log2(x),即以2为底的对数函数 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>sqrt</td> 
   <td>-</td> 
   <td>float sqrt(float x) <br>vec2 sqrt(vec2 x) <br>vec3 sqrt(vec3 x) <br>vec4 sqrt(vec4 x)</td> 
   <td><br>1. 返回 x 的平方根 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>inversesqrt</td> 
   <td>-</td> 
   <td>float inversesqrt(float x) <br>vec2 inversesqrt(vec2 x) <br>vec3 inversesqrt(vec3 x) <br>vec4 inversesqrt(vec4 x)</td> 
   <td><br>1. 返回 x 的平方根的倒数 <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
 </tbody> 
</table>

### 一般函数(common functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abs</td> 
   <td>绝对值函数</td> 
   <td>float abs(float x) <br>vec2 abs(vec2 x) <br>vec3 abs(vec3 x) <br>vec4 abs(vec4 x)</td> 
   <td><br>1. <br>x &gt;= 0 返回 x<br>x &lt; 0 返回 -x <br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>sign</td> 
   <td>符号函数</td> 
   <td>float sign(float x) <br>vec2 sign(vec2 x) <br>vec3 sign(vec3 x) <br>vec4 sign(vec4 x)</td> 
   <td><br>1. <br>x &gt; 0 返回 1 <br>x = 0 返回 0<br>x &lt; 0 返回 -1<br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>floor</td> 
   <td>下取整函数</td> 
   <td>float floor(float x) <br>vec2 floor(vec2 x) <br>vec3 floor(vec3 x) <br>vec4 floor(vec4 x)</td> 
   <td><br>1. 返回 &lt;= x 的最大整数<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 函数仍然使用浮点类型返回整数结果</td> 
  </tr> 
  <tr> 
   <td>ceil</td> 
   <td>上取整函数</td> 
   <td>float ceil(float x) <br>vec2 ceil(vec2 x) <br>vec3 ceil(vec3 x) <br>vec4 ceil(vec4 x)</td> 
   <td><br>1. 返回 &gt;= x 的最小整数<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 函数仍然使用浮点类型返回整数结果</td> 
  </tr> 
  <tr> 
   <td>fract</td> 
   <td>-</td> 
   <td>float fract(float x) <br>vec2 fract(vec2 x) <br>vec3 fract(vec3 x) <br>vec4 fract(vec4 x)</td> 
   <td><br>1. 返回 x 的小数部分,即返回 x - floor(x)<br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>mod</td> 
   <td>取模函数</td> 
   <td>float mod(float x, float y) <br>vec2 mod(vec2 x, vec2 y) <br>vec3 mod(vec3 x, vec3 y) <br>vec4 mod(vec4 x, vec4 y)<br>vec2 mod(vec2 x, float y) <br>vec3 mod(vec3 x, float y) <br>vec4 mod(vec4 x, float y)</td> 
   <td><br>1. 返回 x % y 或者说返回 x - y * floor(x / y)<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数为浮点向量第二参数为浮点标量的函数版本</td> 
  </tr> 
  <tr> 
   <td>min</td> 
   <td>最小值函数</td> 
   <td>float min(float x, float y) <br>vec2 min(vec2 x, vec2 y) <br>vec3 min(vec3 x, vec3 y) <br>vec4 min(vec4 x, vec4 y)<br>vec2 min(vec2 x, float y) <br>vec3 min(vec3 x, float y) <br>vec4 min(vec4 x, float y)</td> 
   <td><br>1. 返回 x 和 y 的较小值<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数为浮点向量第二参数为浮点标量的函数版本</td> 
  </tr> 
  <tr> 
   <td>max</td> 
   <td>最大值函数</td> 
   <td>float max(float x, float y) <br>vec2 max(vec2 x, vec2 y) <br>vec3 max(vec3 x, vec3 y) <br>vec4 max(vec4 x, vec4 y)<br>vec2 max(vec2 x, float y) <br>vec3 max(vec3 x, float y) <br>vec4 max(vec4 x, float y)</td> 
   <td><br>1. 返回 x 和 y 的较大值<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数为浮点向量第二参数为浮点标量的函数版本</td> 
  </tr> 
  <tr> 
   <td>clamp</td> 
   <td>-</td> 
   <td>float clamp(float x, float minVal, float maxVal) <br>vec2 clamp(vec2 x, vec2 minVal, vec2 maxVal) <br>vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal) <br>vec4 clamp(vec4 x, vec4 minVal, vec4 maxVal)<br>vec2 clamp(vec2 x, float minVal, float maxVal) <br>vec3 clamp(vec3 x, float minVal, float maxVal) <br>vec4 clamp(vec4 x, float minVal, float maxVal)</td> 
   <td><br>1. <br>x &gt;= minVal 并且 x &lt;= maxVal 返回 x<br>x &lt; minVal 返回 minVal<br>x &gt; maxVal 返回 maxVal<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数为浮点向量第二参数及第三参数为浮点标量的函数版本</td> 
  </tr> 
  <tr> 
   <td>mix</td> 
   <td>-</td> 
   <td>float mix(float x, float y, float a) <br>vec2 mix(vec2 x, vec2 y, vec2 a) <br>vec3 mix(vec3 x, vec3 y, vec3 a) <br>vec4 mix(vec4 x, vec4 y, vec4 a)<br>vec2 mix(vec2 x, vec2 y, float a) <br>vec3 mix(vec3 x, vec3 y, float a) <br>vec4 mix(vec4 x, vec4 y, float a)</td> 
   <td><br>1. 按 a 对 x 和 y 进行线性插值,即返回 (1 - a) * x + a * y<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数及第二参数为浮点向量第三参数为浮点标量的函数版本</td> 
  </tr> 
  <tr> 
   <td>step</td> 
   <td>-</td> 
   <td>float step(float edge, float x) <br>vec2 step(vec2 edge, vec2 x) <br>vec3 step(vec3 edge, vec3 x) <br>vec4 step(vec4 edge, vec4 x)<br>vec2 step(float edge, vec2 x) <br>vec3 step(float edge, vec3 x) <br>vec4 step(float edge, vec4 x)</td> 
   <td><br>1. <br>x &lt; edge 返回 0<br>x &gt;= edge 返回 1<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数为浮点标量第二参数为浮点向量的函数版本</td> 
  </tr> 
  <tr> 
   <td>smoothstep</td> 
   <td>-</td> 
   <td>float smoothstep(float edge0, float edge1, float x) <br>vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x) <br>vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x) <br>vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x)<br>vec2 smoothstep(float edge0, float edge1, vec2 x) <br>vec3 smoothstep(float edge0, float edge1, vec3 x) <br>vec4 smoothstep(float edge0, float edge1, vec4 x)</td> 
   <td><br>1. <br>x &lt; edge0 返回 0<br>x &gt; edge1 返回 1<br>x &gt;= edge0 并且 x &lt;= edge1 返回 x * x * (3 - 2 * x) (<strong>Hermite多项式</strong>)<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 存在第一参数及第二参数为浮点标量第三参数为浮点向量的函数版本</td> 
  </tr> 
 </tbody> 
</table>

### 几何函数(geometric functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>length</td> 
   <td>长度函数</td> 
   <td>float length(float x) <br>float length(vec2 x) <br>float length(vec3 x) <br>float length(vec4 x)</td> 
   <td><br>1. 返回向量长度<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 如果参数为浮点标量,返回 abs(x)</td> 
  </tr> 
  <tr> 
   <td>distance</td> 
   <td>距离函数</td> 
   <td>float distance(float p0, float p1) <br>float distance(vec2 p0, vec2 p1) <br>float distance(vec3 p0, vec3 p1) <br>float distance(vec4 p0, vec4 p1)</td> 
   <td><br>1. 返回向量间距离,即返回 length(p0 - p1)<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 如果参数为浮点标量,返回 abs(p0 - p1)</td> 
  </tr> 
  <tr> 
   <td>dot</td> 
   <td>点积函数</td> 
   <td>float dot(float x, float y) <br>float dot(vec2 x, vec2 y) <br>float dot(vec3 x, vec3 y) <br>float dot(vec4 x, vec4 y)</td> 
   <td><br>1. 返回向量点乘结果(标量)<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 如果参数为浮点标量,返回 x * y</td> 
  </tr> 
  <tr> 
   <td>cross</td> 
   <td>差积函数</td> 
   <td>vec3 cross(vec3 x, vec3 y)</td> 
   <td><br>1. 返回向量差积结果(向量)<br>2. 参数类型只能为3维浮点向量</td> 
  </tr> 
  <tr> 
   <td>normalize</td> 
   <td>归一化函数</td> 
   <td>float normalize(float x) <br>vec2 normalize(vec2 x) <br>vec3 normalize(vec3 x) <br>vec4 normalize(vec4 x)</td> 
   <td><br>1. 返回向量归一化结果,即返回 x / length(x)<br>2. 参数类型可以为浮点标量或者浮点向量<br>3. 如果参数为浮点标量,返回 1</td> 
  </tr> 
  <tr> 
   <td>faceforward</td> 
   <td>-</td> 
   <td>float faceforward(float N, float I, float Nref) <br>vec2 faceforward(vec2 N, vec2 I, vec2 Nref) <br>vec3 faceforward(vec3 N, vec3 I, vec3 Nref) <br>vec4 faceforward(vec4 N, vec4 I, vec4 Nref)</td> 
   <td><br>1. <br>dot(I, Nref) &lt; 0 返回 N<br>dot(I, Nref) &gt;= 0 返回 -N<br>2. 参数类型可以为浮点标量或者浮点向量</td> 
  </tr> 
  <tr> 
   <td>reflect</td> 
   <td>反射函数</td> 
   <td>float reflect(float I, float N) <br>vec2 reflect(vec2 I, vec2 N) <br>vec3 reflect(vec3 I, vec3 N) <br>vec4 reflect(vec4 I, vec4 N)</td> 
   <td><br>1. I 是入射向量(向量方向为从入射点到反射点),N 为反射面法向量(需要归一化)<br>2. 返回 I - 2.0 * dot(N, I) * N</td> 
  </tr> 
  <tr> 
   <td>refract</td> 
   <td>折射函数</td> 
   <td>float refract(float I, float N, float eta) <br>vec2 refract(vec2 I, vec2 N, float eta) <br>vec3 refract(vec3 I, vec3 N, float eta) <br>vec4 refract(vec4 I, vec4 N, float eta)</td> 
   <td><br>1. I 是入射向量(向量方向为从入射点到反射点,需要归一化),N 为反射面法向量(需要归一化),eta 为相对折射率(入射介质的折射率 / 折射介质的折射率)<br>2. 返回值的计算<a rel="nofollow">如下所示</a></td> 
  </tr> 
 </tbody> 
</table>

k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
    if (k < 0.0)
        R = ReturnType(0) // 不发生折射
    else
        R = eta * I - (eta * dot(N, I) + sqrt(k)) * N;|

### 矩阵函数(matrix functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>matrixCompMult</td> 
   <td>-</td> 
   <td>mat2 matrixCompMult(mat2 x, mat2 y) <br>mat3 matrixCompMult(mat3 x, mat3 y) <br>mat4 matrixCompMult(mat4 x, mat4 y)</td> 
   <td>结果矩阵按如下公式计算 z[i][j] = x[i][j] * y[i][j],<strong>注意与矩阵乘法的区别</strong></td> 
  </tr> 
 </tbody> 
</table>

### 向量关系函数(vector relational functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>lessThan</td> 
   <td>小于函数</td> 
   <td>bvec2 lessThan(vec2 x, vec2 y) <br>bvec3 lessThan(vec3 x, vec3 y) <br>bvec4 lessThan(vec4 x, vec4 y) <br>bvec2 lessThan(ivec2 x, ivec2 y) <br>bvec3 lessThan(ivec3 x, ivec3 y) <br>bvec4 lessThan(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>lessThanEqual</td> 
   <td>小于等于函数</td> 
   <td>bvec2 lessThanEqual(vec2 x, vec2 y) <br>bvec3 lessThanEqual(vec3 x, vec3 y) <br>bvec4 lessThanEqual(vec4 x, vec4 y) <br>bvec2 lessThanEqual(ivec2 x, ivec2 y) <br>bvec3 lessThanEqual(ivec3 x, ivec3 y)<br>bvec4 lessThanEqual(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>greaterThan</td> 
   <td>大于函数</td> 
   <td>bvec2 greaterThan(vec2 x, vec2 y) <br>bvec3 greaterThan(vec3 x, vec3 y) <br>bvec4 greaterThan(vec4 x, vec4 y) <br>bvec2 greaterThan(ivec2 x, ivec2 y) <br>bvec3 greaterThan(ivec3 x, ivec3 y) <br>bvec4 greaterThan(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>greaterThanEqual</td> 
   <td>大于等于函数</td> 
   <td>bvec2 greaterThanEqual(vec2 x, vec2 y) <br>bvec3 greaterThanEqual(vec3 x, vec3 y) <br>bvec4 greaterThanEqual(vec4 x, vec4 y) <br>bvec2 greaterThanEqual(ivec2 x, ivec2 y) <br>bvec3 greaterThanEqual(ivec3 x, ivec3 y)<br>bvec4 greaterThanEqual(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>equal</td> 
   <td>等于函数</td> 
   <td>bvec2 equal(vec2 x, vec2 y) <br>bvec3 equal(vec3 x, vec3 y) <br>bvec4 equal(vec4 x, vec4 y) <br>bvec2 equal(ivec2 x, ivec2 y) <br>bvec3 equal(ivec3 x, ivec3 y) <br>bvec4 equal(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>notEqual</td> 
   <td>不等于函数</td> 
   <td>bvec2 notEqual(vec2 x, vec2 y) <br>bvec3 notEqual(vec3 x, vec3 y) <br>bvec4 notEqual(vec4 x, vec4 y) <br>bvec2 notEqual(ivec2 x, ivec2 y) <br>bvec3 notEqual(ivec3 x, ivec3 y) <br>bvec4 notEqual(ivec4 x, ivec4 y)</td> 
   <td>注意各个函数版本的参数</td> 
  </tr> 
  <tr> 
   <td>any</td> 
   <td>-</td> 
   <td>bool any(bvec2 x) <br>bool any(bvec3 x) <br>bool any(bvec4 x)</td> 
   <td>参数的任一分量为true,则返回true,否则返回false</td> 
  </tr> 
  <tr> 
   <td>all</td> 
   <td>-</td> 
   <td>bool all(bvec2 x) <br>bool all(bvec3 x) <br>bool all(bvec4 x)</td> 
   <td>参数的所有分量为true,则返回true,否则返回false</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>-</td> 
   <td>bvec2 not(bvec2 x) <br>bvec3 not(bvec3 x) <br>bvec4 not(bvec4 x)</td> 
   <td>参数的所有分量取反</td> 
  </tr> 
 </tbody> 
</table>

### 贴图采样函数(texture lookup functions) ###

<table> 
 <thead> 
  <tr> 
   <th>函数名</th> 
   <th>说明</th> 
   <th>示例</th> 
   <th>注意点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>texture2D</td> 
   <td>-</td> 
   <td>vec4 texture2D(sampler2D sampler, vec2 coord) <br>vec4 texture2D(sampler2D sampler, vec2 coord, float bias)</td> 
   <td>bias参数用于调整贴图lod的选取采样(在选取的 mipmap level 上做偏移)</td> 
  </tr> 
  <tr> 
   <td>textureCube</td> 
   <td>-</td> 
   <td>vec4 textureCube(samplerCube sampler, vec3 coord) <br>vec4 textureCube(samplerCube sampler, vec3 coord, float bias)</td> 
   <td>bias参数用于调整贴图lod的选取采样(在选取的 mipmap level 上做偏移)</td> 
  </tr> 
 </tbody> 
</table>

[Link 1]: https://www.khronos.org/registry/OpenGL/index_gl.php