GLSL 中文手冊

基本類型:

基本結(jié)構(gòu)和數(shù)組:

向量的分量訪問:

glsl中的向量(vec2,vec3,vec4)往往有特殊的含義,比如可能代表了一個空間坐標(biāo)(x,y,z,w),或者代表了一個顏色(r,g,b,a),再或者代表一個紋理坐標(biāo)(s,t,p,q)
所以glsl提供了一些更人性化的分量訪問方式.

vector.xyzw 其中xyzw 可以任意組合

vector.rgba 其中rgba 可以任意組合

vector.stpq 其中rgba 可以任意組合

vec4 v=vec4(1.0,2.0,3.0,1.0);
float x = v.x; //1.0
float x1 = v.r; //1.0
float x2 = v[0]; //1.0

vec3 xyz = v.xyz; //vec3(1.0,2.0,3.0)
vec3 xyz1 = vec(v[0],v[1],v[2]); //vec3(1.0,2.0,3.0)
vec3 rgb = v.rgb; //vec3(1.0,2.0,3.0)

vec2 xyzw = v.xyzw; //vec4(1.0,2.0,3.0,1.0);
vec2 rgba = v.rgba; //vec4(1.0,2.0,3.0,1.0);

運算符:

ps 左值與右值:

左值:表示一個儲存位置,可以是變量,也可以是表達式,但表達式最后的結(jié)果必須是一個儲存位置.

右值:表示一個值, 可以是一個變量或者表達式再或者純粹的值.

操作符的優(yōu)先級：決定含有多個操作符的表達式的求值順序，每個操作的優(yōu)先級不同.

操作符的結(jié)合性：決定相同優(yōu)先級的操作符是從左到右計算，還是從右到左計算。

基礎(chǔ)類型間的運算:

glsl中,沒有隱式類型轉(zhuǎn)換,原則上glsl要求任何表達式左右兩側(cè)(l-value),(r-value)的類型必須一致 也就是說以下表達式都是錯誤的:

int a =2.0; //錯誤,r-value為float 而 lvalue 為int.
int a =1.0+2;
float a =2;
float a =2.0+1;
bool a = 0; 
vec3 a = vec3(1.0, 2.0, 3.0) * 2;

下面來分別說說可能遇到的情況:

1.float 與 int:

float與float , int與int之間是可以直接運算的,但float與int不行.它們需要進行一次顯示轉(zhuǎn)換.即要么把float轉(zhuǎn)成int: int(1.0)
,要么把int轉(zhuǎn)成float: float(1) ,以下表達式都是正確的:

int a=int(2.0);
float a= float(2);

int a=int(2.0)*2 + 1;
float a= float(2)*6.0+2.3;

2.float 與 vec(向量) mat(矩陣):

vec,mat這些類型其實是由float復(fù)合而成的,當(dāng)它們與float運算時,其實就是在每一個分量上分別與float進行運算,這就是所謂的逐分量運算.glsl里
大部分涉及vec,mat的運算都是逐分量運算,但也并不全是. 下文中就會講到特例.

逐分量運算是線性的,這就是說 vec 與 float 的運算結(jié)果是還是 vec.

int 與 vec,mat之間是不可運算的, 因為vec和mat中的每一個分量都是 float 類型的. 無法與int進行逐分量計算.

下面枚舉了幾種 float 與 vec,mat 運算的情況

vec3 a = vec3(1.0, 2.0, 3.0);
mat3 m = mat3(1.0);
float s = 10.0;
vec3 b = s * a; // vec3(10.0, 20.0, 30.0)
vec3 c = a * s; // vec3(10.0, 20.0, 30.0)
mat3 m2 = s * m; // = mat3(10.0)
mat3 m3 = m * s; // = mat3(10.0)

3. vec(向量) 與 vec(向量):

兩向量間的運算首先要保證操作數(shù)的階數(shù)都相同.否則不能計算.例如: vec3*vec2 vec4+vec3 等等都是不行的.

它們的計算方式是兩操作數(shù)在同位置上的分量分別進行運算,其本質(zhì)還是逐分量進行的,這和上面所說的float類型的
逐分量運算可能有一點點差異,相同的是 vec 與 vec 運算結(jié)果還是 vec, 且階數(shù)不變.

vec3 a = vec3(1.0, 2.0, 3.0);
vec3 b = vec3(0.1, 0.2, 0.3);
vec3 c = a + b; // = vec3(1.1, 2.2, 3.3)
vec3 d = a * b; // = vec3(0.1, 0.4, 0.9)

image

3. vec(向量) 與 mat(矩陣):

要保證操作數(shù)的階數(shù)相同,且vec與mat間只存在乘法運算.

它們的計算方式和線性代數(shù)中的矩陣乘法相同,不是逐分量運算.

vec2 v = vec2(10., 20.);
mat2 m = mat2(1., 2.,  3., 4.);
vec2 w = m * v; // = vec2(1. * 10. + 3. * 20., 2. * 10. + 4. * 20.)
...

vec2 v = vec2(10., 20.);
mat2 m = mat2(1., 2.,  3., 4.);
vec2 w = v * m; // = vec2(1. * 10. + 2. * 20., 3. * 10. + 4. * 20.)

向量與矩陣的乘法規(guī)則如下:

image

image

4. mat(矩陣) 與 mat(矩陣):

要保證操作數(shù)的階數(shù)相同.

在mat與mat的運算中, 除了乘法是線性代數(shù)中的矩陣乘法外.其余的運算任為逐分量運算.簡單說就是只有乘法是特殊的,其余都和vec與vec運算類似.

mat2 a = mat2(1., 2.,  3., 4.);
mat2 b = mat2(10., 20.,  30., 40.);
mat2 c = a * b; //mat2(1.*10.+3.*20.,2.*10.+4.*20.,1.* 30.+3.*40.,2.* 30.+4.*40.);

mat2 d = a+b;//mat2(1.+10.,2.+20.,3.+30.,4.+40);

矩陣乘法規(guī)則如下:

image

變量限定符:

const:

和C語言類似,被const限定符修飾的變量初始化后不可變,除了局部變量,函數(shù)參數(shù)也可以使用const修飾符.但要注意的是結(jié)構(gòu)變量可以用const修飾,
但結(jié)構(gòu)中的字段不行.

const變量必須在聲明時就初始化 const vec3 v3 = vec3(0.,0.,0.)

局部變量只能使用const限定符.

函數(shù)參數(shù)只能使用const限定符.

struct light {
        vec4 color;
        vec3 pos;
        //const vec3 pos1; //結(jié)構(gòu)中的字段不可用const修飾會報錯.
    };
const light lgt = light(vec4(1.0), vec3(0.0)); //結(jié)構(gòu)變量可以用const修飾

attribute:

attribute變量是全局且只讀的,它只能在vertex shader中使用,只能與浮點數(shù),向量或矩陣變量組合,
一般attribute變量用來放置程序傳遞來的模型頂點,法線,顏色,紋理等數(shù)據(jù)它可以訪問數(shù)據(jù)緩沖區(qū)
(還記得gl.vertexAttribPointer這個函數(shù)吧)

attribute vec4 a_Position;

uniform:

uniform變量是全局且只讀的,在整個shader執(zhí)行完畢前其值不會改變,他可以和任意基本類型變量組合,
一般我們使用uniform變量來放置外部程序傳遞來的環(huán)境數(shù)據(jù)(如點光源位置,模型的變換矩陣等等)
這些數(shù)據(jù)在運行中顯然是不需要被改變的.

uniform vec4 lightPosition;

varying:

varying類型變量是 vertex shader 與 fragment shader 之間的信使,一般我們在 vertex shader 中修改它然后在fragment shader使用它,但不能在
fragment shader中修改它.

//頂點著色器
varying vec4 v_Color;
void main(){ 
    ...
    v_Color = vec4(1.,1.,1.,1);
}

//片元著色器
...
varying vec4 v_Color;
void main() {
  gl_FragColor = v_Color;
}
...

要注意全局變量限制符只能為 const、attribute、uniform和varying中的一個.不可復(fù)合.

函數(shù)參數(shù)限定符:

函數(shù)的參數(shù)默認是以拷貝的形式傳遞的,也就是值傳遞,任何傳遞給函數(shù)參數(shù)的變量,其值都會被復(fù)制一份,然后再交給函數(shù)內(nèi)部進行處理.
我們可以為參數(shù)添加限定符來達到傳遞引用的目的,glsl中提供的參數(shù)限定符如下:

in 是函數(shù)參數(shù)的默認限定符,最終真正傳入函數(shù)形參的其實是實參的一份拷貝.在函數(shù)中,修改in修飾的形參不會影響到實參變量本身.

out 它的作用是向函數(shù)外部傳遞新值,out模式下傳遞進來的參數(shù)是write-only的(可寫不可讀).就像是一個"坑位",坑位中的值需要函數(shù)給他賦予.
在函數(shù)中,修改out修飾的形參會影響到實參本身.

inout inout下,形參可以被理解為是一個帶值的"坑位",及可讀也可寫,在函數(shù)中,修改inout修飾的形參會影響到實參本身.

glsl的函數(shù):

glsl允許在程序的最外部聲明函數(shù).函數(shù)不能嵌套,不能遞歸調(diào)用,且必須聲明返回值類型(無返回值時聲明為void) 在其他方面glsl函數(shù)與c函數(shù)非常類似.

vec4 getPosition(){ 
    vec4 v4 = vec4(0.,0.,0.,1.);
    return v4;
}

void doubleSize(inout float size){
    size= size*2.0  ;
}
void main() {
    float psize= 10.0;
    doubleSize(psize);
    gl_Position = getPosition();
    gl_PointSize = psize;
}

構(gòu)造函數(shù):

glsl中變量可以在聲明的時候初始化,float pSize = 10.0 也可以先聲明然后等需要的時候在進行賦值.

聚合類型對象如(向量,矩陣,數(shù)組,結(jié)構(gòu)) 需要使用其構(gòu)造函數(shù)來進行初始化. vec4 color = vec4(0.0, 1.0, 0.0, 1.0);

//一般類型
float pSize = 10.0;
float pSize1;
pSize1=10.0;
...

//復(fù)合類型
vec4 color = vec4(0.0, 1.0, 0.0, 1.0);
vec4 color1;
color1 =vec4(0.0, 1.0, 0.0, 1.0);
...

//結(jié)構(gòu)
struct light {
    float intensity;
    vec3 position;
};
light lightVar = light(3.0, vec3(1.0, 2.0, 3.0));

//數(shù)組
const float c[3] = float[3](5.0, 7.2, 1.1);

類型轉(zhuǎn)換:

glsl可以使用構(gòu)造函數(shù)進行顯式類型轉(zhuǎn)換,各值如下:

bool t= true;
bool f = false;

int a = int(t); //true轉(zhuǎn)換為1或1.0
int a1 = int(f);//false轉(zhuǎn)換為0或0.0

float b = float(t);
float b1 = float(f);

bool c = bool(0);//0或0.0轉(zhuǎn)換為false
bool c1 = bool(1);//非0轉(zhuǎn)換為true

bool d = bool(0.0);
bool d1 = bool(1.0);

精度限定:

glsl在進行光柵化著色的時候,會產(chǎn)生大量的浮點數(shù)運算,這些運算可能是當(dāng)前設(shè)備所不能承受的,所以glsl提供了3種浮點數(shù)精度,我們可以根據(jù)不同的設(shè)備來使用合適的精度.

在變量前面加上 highp mediump lowp 即可完成對該變量的精度聲明.

lowp float color;
varying mediump vec2 Coord;
lowp ivec2 foo(lowp mat3);
highp mat4 m;

我們一般在片元著色器(fragment shader)最開始的地方加上 precision mediump float; 便設(shè)定了默認的精度.這樣所有沒有顯式表明精度的變量
都會按照設(shè)定好的默認精度來處理.

如何確定精度:

變量的精度首先是由精度限定符決定的,如果沒有精度限定符,則要尋找其右側(cè)表達式中,已經(jīng)確定精度的變量,一旦找到,那么整個表達式都將在該精度下運行.如果找到多個,
則選擇精度較高的那種,如果一個都找不到,則使用默認或更大的精度類型.

uniform highp float h1;
highp float h2 = 2.3 * 4.7; //運算過程和結(jié)果都 是高精度
mediump float m;
m = 3.7 * h1 * h2; //運算過程 是高精度
h2 = m * h1; //運算過程 是高精度
m = h2 – h1; //運算過程 是高精度
h2 = m + m; //運算過程和結(jié)果都 是中等精度
void f(highp float p); // 形參 p 是高精度
f(3.3); //傳入的 3.3是高精度

invariant關(guān)鍵字:

由于shader在編譯時會進行一些內(nèi)部優(yōu)化,可能會導(dǎo)致同樣的運算在不同shader里結(jié)果不一定精確相等.這會引起一些問題,尤其是vertx shader向fragmeng shader傳值的時候.
所以我們需要使用invariant 關(guān)鍵字來顯式要求計算結(jié)果必須精確一致. 當(dāng)然我們也可使用 #pragma STDGL invariant(all)來命令所有輸出變量必須精確一致,
但這樣會限制編譯器優(yōu)化程度,降低性能.

#pragma STDGL invariant(all) //所有輸出變量為 invariant
invariant varying texCoord; //varying在傳遞數(shù)據(jù)的時候聲明為invariant

限定符的順序:

當(dāng)需要用到多個限定符的時候要遵循以下順序:

1.在一般變量中: invariant > storage > precision

2.在參數(shù)中: storage > parameter > precision

我們來舉例說明:

invariant varying lowp float color; // invariant > storage > precision

void doubleSize(const in lowp float s){ //storage > parameter > precision
    float s1=s;
}

預(yù)編譯指令:

以 # 開頭的是預(yù)編譯指令,常用的有:

#define #undef #if #ifdef #ifndef #else
#elif #endif #error #pragma #extension #version #line

比如 #version 100 他的意思是規(guī)定當(dāng)前shader使用 GLSL ES 1.00標(biāo)準(zhǔn)進行編譯,如果使用這條預(yù)編譯指令,則他必須出現(xiàn)在程序的最開始位置.

內(nèi)置的宏:

__LINE__ : 當(dāng)前源碼中的行號.

__VERSION__ : 一個整數(shù),指示當(dāng)前的glsl版本 比如 100 ps: 100 = v1.00

GL_ES : 如果當(dāng)前是在 OPGL ES 環(huán)境中運行則 GL_ES 被設(shè)置成1,一般用來檢查當(dāng)前環(huán)境是不是 OPENGL ES.

GL_FRAGMENT_PRECISION_HIGH : 如果當(dāng)前系統(tǒng)glsl的片元著色器支持高浮點精度,則設(shè)置為1.一般用于檢查著色器精度.

實例:

1.如何通過判斷系統(tǒng)環(huán)境,來選擇合適的精度:

#ifdef GL_ES //
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
#endif

2.自定義宏:

#define NUM 100
#if NUM==100
#endif

內(nèi)置的特殊變量

glsl程序使用一些特殊的內(nèi)置變量與硬件進行溝通.他們大致分成兩種 一種是 input類型,他負責(zé)向硬件(渲染管線)發(fā)送數(shù)據(jù).
另一種是output類型,負責(zé)向程序回傳數(shù)據(jù),以便編程時需要.

在 vertex Shader 中:

output 類型的內(nèi)置變量:

在 fragment Shader 中:

input 類型的內(nèi)置變量:

output 類型的內(nèi)置變量:

內(nèi)置的常量

glsl提供了一些內(nèi)置的常量,用來說明當(dāng)前系統(tǒng)的一些特性. 有時我們需要針對這些特性,對shader程序進行優(yōu)化,讓程序兼容度更好.

在 vertex Shader 中:

1.const mediump int gl_MaxVertexAttribs>=8

gl_MaxVertexAttribs 表示在vertex shader(頂點著色器)中可用的最大attributes數(shù).這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 8 個.

2.const mediump int gl_MaxVertexUniformVectors >= 128

gl_MaxVertexUniformVectors 表示在vertex shader(頂點著色器)中可用的最大uniform vectors數(shù). 這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 128 個.

3.const mediump int gl_MaxVaryingVectors >= 8

gl_MaxVaryingVectors 表示在vertex shader(頂點著色器)中可用的最大varying vectors數(shù). 這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 8 個.

4.const mediump int gl_MaxVertexTextureImageUnits >= 0

gl_MaxVaryingVectors 表示在vertex shader(頂點著色器)中可用的最大紋理單元數(shù)(貼圖). 這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
甚至可以一個都沒有(無法獲取頂點紋理)

5.const mediump int gl_MaxCombinedTextureImageUnits >= 8

gl_MaxVaryingVectors 表示在 vertex Shader和fragment Shader總共最多支持多少個紋理單元. 這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 8 個.

在 fragment Shader 中:

1.const mediump int gl_MaxTextureImageUnits >= 8

gl_MaxVaryingVectors 表示在 fragment Shader(片元著色器)中能訪問的最大紋理單元數(shù),這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 8 個.

2.const mediump int gl_MaxFragmentUniformVectors >= 16

gl_MaxFragmentUniformVectors 表示在 fragment Shader(片元著色器)中可用的最大uniform vectors數(shù),這個值的大小取決于 OpenGL ES 在某設(shè)備上的具體實現(xiàn),
不過最低不能小于 16 個.

3.const mediump int gl_MaxDrawBuffers = 1

gl_MaxDrawBuffers 表示可用的drawBuffers數(shù),在OpenGL ES 2.0中這個值為1, 在將來的版本可能會有所變化.

glsl中還有一種內(nèi)置的uniform狀態(tài)變量, gl_DepthRange 它用來表明全局深度范圍.

結(jié)構(gòu)如下:

struct gl_DepthRangeParameters {
 highp float near; // n
 highp float far; // f
 highp float diff; // f - n
 };
 uniform gl_DepthRangeParameters gl_DepthRange;

除了 gl_DepthRange 外的所有uniform狀態(tài)常量都已在glsl 1.30 中廢棄.

流控制

glsl的流控制和c語言非常相似,這里不必再做過多說明,唯一不同的是片段著色器中有一種特殊的控制流discard.
使用discard會退出片段著色器，不執(zhí)行后面的片段著色操作。片段也不會寫入幀緩沖區(qū)。

for (l = 0; l < numLights; l++)
{
    if (!lightExists[l]);
        continue;
    color += light[l];
}
...

while (i < num)
{
    sum += color[i];
    i++;
}
...

do{
    color += light[lightNum];
    lightNum--;
}while (lightNum > 0)


...

if (true)
    discard;

內(nèi)置函數(shù)庫

glsl提供了非常豐富的函數(shù)庫,供我們使用,這些功能都是非常有用且會經(jīng)常用到的. 這些函數(shù)按功能區(qū)分大改可以分成7類:

通用函數(shù):

下文中的 類型 T可以是 float, vec2, vec3, vec4,且可以逐分量操作.

角度&三角函數(shù):

下文中的 類型 T可以是 float, vec2, vec3, vec4,且可以逐分量操作.

指數(shù)函數(shù):

下文中的 類型 T可以是 float, vec2, vec3, vec4,且可以逐分量操作.

幾何函數(shù):

下文中的 類型 T可以是 float, vec2, vec3, vec4,且可以逐分量操作.

矩陣函數(shù):

mat可以為任意類型矩陣.

向量函數(shù):

下文中的 類型 T可以是 vec2, vec3, vec4, 且可以逐分量操作.

bvec指的是由bool類型組成的一個向量:

vec3 v3= vec3(0.,0.,0.);
vec3 v3_1= vec3(1.,1.,1.);
bvec3 aa= lessThan(v3,v3_1); //bvec3(true,true,true)

紋理查詢函數(shù):

圖像紋理有兩種 一種是平面2d紋理,另一種是盒紋理,針對不同的紋理類型有不同訪問方法.

紋理查詢的最終目的是從sampler中提取指定坐標(biāo)的顏色信息. 函數(shù)中帶有Cube字樣的是指 需要傳入盒狀紋理. 帶有Proj字樣的是指帶投影的版本.

以下函數(shù)只在vertex shader中可用:

vec4 texture2DLod(sampler2D sampler, vec2 coord, float lod);
vec4 texture2DProjLod(sampler2D sampler, vec3 coord, float lod);
vec4 texture2DProjLod(sampler2D sampler, vec4 coord, float lod);
vec4 textureCubeLod(samplerCube sampler, vec3 coord, float lod);

以下函數(shù)只在fragment shader中可用:

vec4 texture2D(sampler2D sampler, vec2 coord, float bias);
vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);
vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);
vec4 textureCube(samplerCube sampler, vec3 coord, float bias);

在 vertex shader 與 fragment shader 中都可用:

vec4 texture2D(sampler2D sampler, vec2 coord);
vec4 texture2DProj(sampler2D sampler, vec3 coord);
vec4 texture2DProj(sampler2D sampler, vec4 coord);
vec4 textureCube(samplerCube sampler, vec3 coord);

官方的shader范例:

下面的shader如果你可以一眼看懂,說明你已經(jīng)對glsl語言基本掌握了.

Vertex Shader:

uniform mat4 mvp_matrix; //透視矩陣 * 視圖矩陣 * 模型變換矩陣
uniform mat3 normal_matrix; //法線變換矩陣(用于物體變換后法線跟著變換)
uniform vec3 ec_light_dir; //光照方向
attribute vec4 a_vertex; // 頂點坐標(biāo)
attribute vec3 a_normal; //頂點法線
attribute vec2 a_texcoord; //紋理坐標(biāo)
varying float v_diffuse; //法線與入射光的夾角
varying vec2 v_texcoord; //2d紋理坐標(biāo)
void main(void)
{
 //歸一化法線
 vec3 ec_normal = normalize(normal_matrix * a_normal);
 //v_diffuse 是法線與光照的夾角.根據(jù)向量點乘法則,當(dāng)兩向量長度為1是 乘積即cosθ值
 v_diffuse = max(dot(ec_light_dir, ec_normal), 0.0);
 v_texcoord = a_texcoord;
 gl_Position = mvp_matrix * a_vertex;
}

Fragment Shader:

precision mediump float;
uniform sampler2D t_reflectance;
uniform vec4 i_ambient;
varying float v_diffuse;
varying vec2 v_texcoord;
void main (void)
{
 vec4 color = texture2D(t_reflectance, v_texcoord);
 //這里分解開來是 color*vec3(1,1,1)*v_diffuse + color*i_ambient
 //色*光*夾角cos + 色*環(huán)境光
 gl_FragColor = color*(vec4(v_diffuse) + i_ambient);
}

源自該鏈接，記錄下方便觀看：
https://github.com/wshxbqq/GLSL-Card/edit/master/README.md