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;