GLSL ES入门手册（1）

在正式介绍GLSL ES之前，我们需要对OpenGL和OpenGL ES有一个一般的了解:

GLSL（ES）作为一种类似C的语言，当然也是一种强类型化的语言，并且继承了C语言的大多数特征.

定义变量时必须指定类型.

英语，数字和下划线可以用于变量命名，但是您需要注意以下几点:

1

int age = 18;

一个表达式可以定义多个变量，需要用，

分隔.

1
2

int age, balance;
int a, b = 110;

在定义函数时，如果函数具有返回值，则需要指定返回值的类型. 如果没有返回值，则需要指定void.

如果函数具有参数，则还需要指定参数的类型. 如果没有参数，则可以将其保留为空白或用空白填充（通常不填充）.

1
2
3
4
5
6
7
8
9

// 没有返回值没有参数的 main 函数
void main()
    // ...


// 接收两个 int 类型参数并返回 int 类型的值的 sum 函数
int sum(int a, int b)
    return a + b;

单行注释: //后面加上文字

1

// 我是单行注释

多行注释: 使用/ *和* /换行多行文本

1
2
3
4

/*
我是第一行注释
我是第二行注释
*/

原始类型包括intscalar矩阵，unit，float和boolscalar矩阵，具体含义如下:

关键字含义示例

签名整数

int余额= -666;

无符号整数

年龄= 18u;

浮动

单浮点标量

float pi = 3.14;

布尔值（布尔）

bool isHandsome = true;

向量可以包含2到4个组件，并且组件类型可以是上述任何基本类型.

下表中的

n是组件数

关键字组件类型的含义示例

浮动

包含n个浮点型分量的向量

包含n个int类型分量的向量

包含n个uint类型分量的向量

包含n个布尔型分量的向量

通常，我们使用vecn就足够了.

我们可以使用不同的构造函数来创建相应的向量:

1
2
3

vec2 coord = vec2(0.5, 0.5); // 含有 2 个 float 类型分量的向量
ivec3 police = ivec3(1, 1, 0); // 含有 3 个 int 类型分量的向量
bve hello = bve(true, false, true, false); // 含有 4 个 bool 类型分量的向量

仅传入一个参数时，其他值将自动设置为第一个参数:

1

vec3 three = vec3(0.1); // 等同于 vec3(0.1, 0.1, 0.1)

您还可以将向量用作参数，并将其传递给另一个向量构造函数:

1
2

vec2 two = vec2(0.1, 0.2);
vec3 three = vec3(two, 0.3); // vec3(0.1, 0.2, 0.3)

使用“大”向量作为参数创建“小”向量将自动丢弃多余的值:

1
2

ve four = ve(0.1, 0.2, 0.3, 0.4);
vec3 three = vec3(four); // 等同于 vec3(0.1, 0.2, 0.3)，抛弃了 0.4

与其他语言一样，GLSL也使用. 运算符以获取向量的属性，其中x，y，z和w分别对应于向量的第一，第二，第三和第四分量:

1
2
3
4
5
6

vec2 coord = vec2(1.0, 0.5);
float x = coord.x; // 1.0
float y = coord.y; // 0.5
ve four = ve(0.1, 0.2, 0.3, 0.4);
float z = four.z; // 0.3
float w = four.w; // 0.4

此外，您可以将rgba用作颜色矢量，或将stpq用作纹理坐标矢量以获取其分量:

1
2
3
4
5
6

ve color = ve(0.6, 0.8, 1,0, 0.5);
float r = color.r; // 0.6
float a = color.a; // 0.5
ve texCoord = ve(0.2, 0.4, 0.6, 0.8);
float t = texCoord.t; // 0.4
float p = texCoord.p; // 0.6

在GLSL中，您可以使用上述字母的任意组合（即向量的不同组成部分）来创建新的向量. 这种行为称为重组:

1
2
3
4
5
6

ve coord = ve(0.1, 0.2, 0.3, 0.4);
vec2 two = coord.xy; // vec2(0.1, 0.2)
vec3 three = coord.xzw; // vec3(0.1, 0.3, 0.4)
ve four = coord.wzyx; // ve(0.4, 0.3, 0.2, 0.1)
ve boom = coord.xyzw + coord.wzyx; // ve(0.5, 0.5, 0.5, 0.5)
ve hello = ve(coord.zyx, 0.0); // ve(0.3, 0.2, 0.1, 0.0)

类似于表的复合数据类型. 矩阵最多可支持4行4列数据，其元素只能是float类型.

下表中的

n和m是2到4之间的任何数字

关键字含义示例

代表n列n行的浮点矩阵

表示n列m行的浮点矩阵

使用不同的构造函数来创建相应的矩阵:

1
2
3
4
5
6
7

// 创建一个 2x2 的矩阵
mat2 two = mat2(1.0, 0.5, // 第一列
                0.5, 1.0); // 第二列
// 创建一个 3x3 的矩阵
mat3 three = mat3(0.1, 0.2, 0.3, // 第一列
                  0.4, 0.5, 0.6, // 第二列
                  0.7, 0.8, 0.9); // 第三列

仅传入一个参数时，将自动添加0:

1
2

mat2 two = mat2(1.0); // 等同于 mat2(1.0, 0.0)
mat3 three = mat3(1.0); // 等同于 mat3(1.0, 0.0, 0.0)

我们还可以将向量传递给构造函数以创建矩阵:

1
2
3
4
5
6

vec2 a = vec2(1.0, 0.0);
vec2 b = vec2(0.5, 0.1);
mat2 four = mat2(a, b); // 等同于 mat2(1.0, 0.0, 0.5, 0.1)
// 创建一个 2x3 的矩阵
mat2x3 haha = mat2x3(a, 0.3,
                     b, 0.2); // 等同于 mat2x3(1.0, 0.0, 0.3, 0.5, 0.1, 0.2)

您可以使用[]运算符获取矩阵的元素（下标从0开始）:

1
2
3
4

mat3 three = mat3(0.1, 0.2, 0.3, // 第一列
                  0.4, 0.5, 0.6, // 第二列
                  0.7, 0.8, 0.9); // 第三列
float el = three[0][2]; // 获取第一列第三行的元素：0.3

您还可以通过[]运算符和组件名称获取元素:

1

float el = three[0].z; // 同上，获取第一列第三行的元素：0.3

在GLSL中，我们需要使用采样器来获取纹理信息.

只能通过Shader外部的宿主语言通过OpenGL API分配采样器.

有多种类型的采样器，这里只列出了一些普通的采样器...

关键字含义

sampler2D

用于访问2D纹理的句柄

sampler3D

用于访问3D纹理的句柄

samplerCube

用于访问立方体贴图纹理的手柄

sampler2DArray

用于访问2D纹理数组的句柄

采样器必须使用统一关键字修饰（稍后我们将讨论统一）:

1

uniform sampler2D texture;

GLSL允许您使用struct关键字来自定义新类型. 新的自定义类型可以包含已经定义的其他类型:

1
2
3
4
5
6

// 定义一个名为 circle 的类型，包含一个浮点型成员和一个四维向量成员
struct circle 
    float radius;
    ve color;
;
circle myCircle; // 定义一个 circle 类型的变量

定义新结构时，可以包括已经定义的结构，但是不能在结构中定义新结构:

1
2
3
4
5

struct S  float f; ;
struct T 
    S s; // 可
    struct  ... ; // 不可

GLSL仅支持一维数组，变量名后仅需要两个方括号（[]），并且数组的大小必须用方括号括起来. 数组的大小必须大于0. 可以使用常量，但不能使用变量.

1
2
3
4
5

// 使用字面量
float values[3];
// 使用常量
const int COUNT = 3;
float values2[COUNT];

作为函数的返回值类型:

1

float[5] getValues()  ... 

使用构造函数初始化数组:

1
2
3
4
5

// 下面这 4 种方式是一样的
float[3] a = float[3](0.1, 0.2, 0.3);
float[] a = float[3](0.1, 0.2, 0.3);
float[3] a = float[](0.1, 0.2, 0.3);
float[] a = float[](0.1, 0.2, 0.3);

还可以使用[]运算符获取数组中的元素（下标从0开始）:

1
2

float a[3] = float[3](0.1, 0.2, 0.3);
float el = a[1]; // 0.2

数组的长度（int类型）可以通过数组本身的length（）函数获得:

1

int b = a.length();

OpenGL ES注册表（OpenGL ES数据页面）

OpenGL ES 3快速参考卡

GLSL ES规范3.00（GLSL ES规范3.0）

OpenGL ES 3.0参考页

微信推文版本

个人博客: 菜鸟小筹码

开放源代码主页: Chen Pipi

Eazax-CCC游戏开发支架

我是Chen Pipi，这是我由公众运营的个人帐户，主要关注但不限于游戏开发，前端和后端技术记录以及共享.

尽管收效甚微，但每个原件都非常努力，而您的关注是我的原动力！

输入和输出.

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-234665-1.html