OpenGL ES着色器语言之操作数（官方文档第五章）

5.1操作数

OpenGL ES着色器语言包含如下操作符.

5.2数组下标

         数组元素通过数组下标操作符([ ])进行访问.这是操作数组的唯一操作符,举个访问数组元素的例子:

                   diffuseColor += lightIntensity[3] * NdotL;

5.3函数调用

        如果一个函数有返回值,那么通常这个函数调用会用在表达式中.

5.4构造器

        构造器使用函数调用语法,函数名是一个基本类型的关键字或者结构体名字,在初始化器或表达式中使用.参数被用来初始化要构造的值.构造器可以将一个数据标量类型转换为另一个标量类型,或者从较小的类型转换为较大的类型,或者从较大的类型转为较小的类型.

5.4.1 转换和标量构造器

        标量之间转换:

int (bool)         //将布尔型值转换成整数

int (float)         //将浮点数值转换成整数

float (bool)         //将布尔型值转换成浮点数

float(int)         //将整型值转换成浮点数

bool(int)         //将整数值转换成布尔型值

bool(float)         //将浮点数值转换成布尔型值

       当构造器将一个float转换成int时,浮点数的小数部分将被自动舍弃掉.

       当int和float转换成bool时,0和0.0被转换成false,非0值将被转换成true.当构造器将bool值转换成int或float时,false被转换成0或0.0, true被转换成1或1.0.

       等价构造器,如float(float)也是合法的,但很少使用到.

       如果构造器的参数不是标量,如向量,那么构造器将取其第一个元素.如float (vec3)构造器将取vec3中的第一个值.

5.4.2向量和矩阵构造器

        构造器也可以用来从标量集合,向量,矩阵中创建向量和矩阵.同时可以缩短向量长度.

        如果使用一个单一的标量来初始化向量,那么向量的所有值均使用该值进行初始化.如果使用一个单一的标量来初始化矩阵,那么矩阵的对角线的所有元素均会被初始化为该值,但其他元素将会被初始化为0.0

        如果一个向量通过多个标量,向量或矩阵或这几种的混合来构造,那么向量的元素将按照参数列表的顺序来初始化.构造器将从参数列表中按从左到右的顺序去取参数,如果参数有多个值,那么再依次从这个参数中将值取出.构造矩阵也是类似的.矩阵元素将按照列为主要顺序来构造.构造器将依次从参数列表中取出参数值来构造矩阵的元素.如果参数列表中的值的个数超过矩阵或向量的元素个数的话,将会引起错误.

        如果使用一个矩阵来构造矩阵的话,那么,参数矩阵中的元素值将放置到新矩阵的相应位置.

        如果基本类型(int , float, bool)作为参数传进构造器,但是要构造的元素类型和传进来的数据类型不同,那么将会使用类型转换.

vec3(float) // initializes each component of with the float
vec4(ivec4) // makes a vec4 with component-wise conversion
vec2(float, float) // initializes a vec2 with 2 floats
ivec3(int, int, int) // initializes an ivec3 with 3 ints
bvec4(int, int, float, float) // uses 4 Boolean conversions
vec2(vec3) // drops the third component of a vec3
vec3(vec4) // drops the fourth component of a vec4
vec3(vec2, float) // vec3.x = vec2.x, vec3.y = vec2.y, vec3.z = float
vec3(float, vec2) // vec3.x = float, vec3.y = vec2.x, vec3.z = vec2.y
vec4(vec3, float)
vec4(float, vec3)
vec4(vec2, vec2)

vec4 color = vec4(0.0, 1.0, 0.0, 1.0);
vec4 rgba = vec4(1.0); // sets each component to 1.0
vec3 rgb = vec3(color); // drop the 4th component

mat2(float)
mat3(float)
mat4(float)

mat2(vec2, vec2);
mat3(vec3, vec3, vec3);
mat4(vec4, vec4, vec4, vec4);
mat2(float, float,
float, float);
mat3(float, float, float,
float, float, float,
float, float, float);
mat4(float, float, float, float,
float, float, float, float,
float, float, float, float,
float, float, float, float);

5.4.3结构体构造器

       一旦结构体被定义,并给了一个类型名,那么和其同名的构造器就可以使用了.

struct light {
float intensity;
vec3 position;
};
light lightVar = light(3.0, vec3(1.0, 2.0, 3.0));

       传进构造器的参数必须和结构体里面声明的具有相同的顺序和类型.

       结构体构造器可以用于初始化器或者用在表达式中.

5.5向量组件

       向量中每个组件的名称都使用一个单独的字符来表示.常用的位置,颜色,或者纹理坐标向量的组件直接和几个便利的数字相关联.访问向量中的组件可以使用向量名(.)组件名的方式.

       支持的组件名称如下:

       组件名称x,r,s在向量中是表示同一个组件的同义词.

       注意,为了不和颜色向量中的r(红色)混淆,纹理向量中的第三个组件名称使用了p.

       访问超出向量个数的组件会引起错误:

vec2 pos;
pos.x // is legal
pos.z // is illegal

       组件选择语法可以一次选择多个组件:

vec4 v4;
v4.rgba; // is a vec4 and the same as just using v4,
v4.rgb; // is a vec3,
v4.b; // is a float,
v4.xy; // is a vec2,
v4.xgba; // is illegal - the component names do not come from
// the same set.

        通过移动和替换组件可以产生不同的向量:

vec4 pos = vec4(1.0, 2.0, 3.0, 4.0);
vec4 swiz= pos.wzyx; // swiz = (4.0, 3.0, 2.0, 1.0)
vec4 dup = pos.xxyy; // dup = (1.0, 1.0, 2.0, 2.0)

        组件组符号可以出现在左值中,也可以出现在右值中.

vec4 pos = vec4(1.0, 2.0, 3.0, 4.0);
pos.xw = vec2(5.0, 6.0); // pos = (5.0, 2.0, 3.0, 6.0)
pos.wx = vec2(7.0, 8.0); // pos = (8.0, 2.0, 3.0, 7.0)
pos.xx = vec2(3.0, 4.0); // illegal - 'x' used twice
pos.xy = vec3(1.0, 2.0, 3.0); // illegal - mismatch between vec2 and vec3

        数组下标索引语法同样适用于向量.所以:

vec4   pos;

中pos[2]表示第三个元素，与使用pos.z是等价的。

5.6  矩阵组件

        访问矩阵组件可以使用数组的下标索引语法。使用一维数组访问矩阵表示你要访问矩阵中对应的那一列组件，即返回相应列所有元素的向量。二位数组才是具体的访问某一个组件。由于矩阵是列优先的，因此，使用数组来索引矩阵元素的时候，数组的第一维表示列，第二维表示行。

mat4 m;
m[1] = vec4(2.0); // sets the second column to all 2.0
m[0][0] = 1.0; // sets the upper left element to 1.0
m[2][3] = 2.0; // sets the 4th element of the third column to 2.0

       如果下标越界，将引起编译时错误。

5.7结构体和字段

       结构体字段的访问也是要用到点操作符的（.）。

       可用于结构体的操作有如下几种：

       等于和赋值运算符只有两个操作数类型是同一个结构体时才有意义。即使两个结构体的名称和字段一模一样，他们也不是相等的。包含矩阵和采样器类型的结构体的赋值和等于操作是未定义的。

Struct S {int x;};
S a;
{
struct S {int x;};
S b;
a = b; // error: type mismatch
}

5.8  赋值

        赋值表达式结构如下：

                 lvalue-expression = expression;

        lvalue-expression 表示左值表达式，通过赋值运算符“=”将expression表达式的值赋给lvalue-expression；表达式和左值拥有相同的类型才会编译。所有的类型转换都必须显示地通过构造器来指定。左值必须是可写的。

        支持 += 、 -= 、 *= 、 /=等运算符。

        保留 %= 、<<= 、 >>=、 |=和^=等运算符以便后面修订用。

        读取一个未被写入或初始化的变量是合法的，但其值是未定义的。

5.9  表达式

        在着色语言中表达式由以下方式创建：

• bool. int, float型常量，所有向量类型，所有矩阵类型。
• 所有类型的构造器
• 所有类型的变量名，除了不跟下标的数组名外
• 带下标的数组名
• 不带下标的数组名。一般只用在函数参数传递中。
• 带返回值的函数调用。
• 组件字段选择器和数组下标返回值。
• 括号表达式。任何表达式都可以是括号表达式。
• 二进制运算符 + 、 - 、 * 、 /
• ％保留修订用
• 一元负操作符（－），自加（＋＋），自减（－－）操作符。
• 比较运算符。大于（＞），小于（＜），大于等于（＞＝），小于等于（＜＝）。如果想比较向量，使用内建函数lessThan,lessThanEqual,greaterThan,greaterThanEqual。
• 等于（=）和不等于（！=）运算符。除了数组，包含数组的结构体，采样器，包含采样器的结构体外其他类型都可以使用。如果想让组件按位比较，使用内建的函数equal和notEqual。
• 逻辑二进制运算符（&&， ||， ^）。
• 逻辑一元运算符非（！）
• 逗号运算符。逗号运算符返回表达式序列中最后一个的结果。
• 三元选择运算符（？：）
• 运算符（＆，｜，＾，～，＞＞，＜＜）保留修订用。
  

5.10  常量表达式

　 　 常量表达式可以是以下几种：

• 字符值（如5或true）
• 全局或本地使用const修饰的变量，函数参数除外
• 返回常量数组，常量矩阵的某个元素或常量结构体的某个字段
• 参数都是常量表达式的结构体
• 所有参数都是常量表达式的内建函数类型，除了纹理查找函数外。

　 　以下不能用在常量表达式：

• 用户自定义的函数
• uniform,attribute,varying变量　 　 　 　
  

　 　数组变量不能使常量表达式，因为常量必须在声明时进行初始化，但是数组没有初始化机制

5.11  向量和矩阵操作

        对矩阵和向量操作就是对向量和矩阵的每一个单独组建进行操作。举个例子

（１）向量和一个浮点数或整数相加，结果是向量的每一个元素都和该浮点数相加

vec3 v, u;
float f;
v = u + f;
等价于:
v.x = u.x + f;
v.y = u.y + f;
v.z = u.z + f;

（２）向量和向量相加，结果是两个向量的对应位置的组件分别相加

vec3 v, u, w;
w = v + u;

等价于：

w.x = v.x + u.x;
w.y = v.y + u.y;
w.z = v.z + u.z;

　 这对于大部分操作符和所有的整数、浮点数向量和矩阵类型都是类似的操作。例外是矩阵和向量的乘法，矩阵和矩阵的乘法。如：

（３）向量乘以矩阵，结果是

vec3 v, u;
mat3 m;
u = v * m;
等价于：
u.x = dot(v, m[0]); // m[0] is the left column of m
u.y = dot(v, m[1]); // dot(a,b) is the inner (dot) product of a and b
u.z = dot(v, m[2]);

（４）矩阵乘以向量，结果是矩阵的各行和向量相乘
u = m * v;
等价于：
u.x = m[0].x * v.x + m[1].x * v.y + m[2].x * v.z;
u.y = m[0].y * v.x + m[1].y * v.y + m[2].y * v.z;
u.z = m[0].z * v.x + m[1].z * v.y + m[2].z * v.z;

（５）矩阵乘以矩阵，前一个矩阵的行乘以后一个矩阵的列
mat m, n, r;
r = m * n;
等价于：
r[0].x = m[0].x * n[0].x + m[1].x * n[0].y + m[2].x * n[0].z;
r[1].x = m[0].x * n[1].x + m[1].x * n[1].y + m[2].x * n[1].z;
r[2].x = m[0].x * n[2].x + m[1].x * n[2].y + m[2].x * n[2].z;
r[0].y = m[0].y * n[0].x + m[1].y * n[0].y + m[2].y * n[0].z;
r[1].y = m[0].y * n[1].x + m[1].y * n[1].y + m[2].y * n[1].z;
r[2].y = m[0].y * n[2].x + m[1].y * n[2].y + m[2].y * n[2].z;
r[0].z = m[0].z * n[0].x + m[1].z * n[0].y + m[2].z * n[0].z;
r[1].z = m[0].z * n[1].x + m[1].z * n[1].y + m[2].z * n[1].z;
r[2].z = m[0].z * n[2].x + m[1].z * n[2].y + m[2].z * n[2].z;