GLSL 代表 openGL Shading Language，openGL 著色語(yǔ)言

GLSL 中文手冊(cè)

基本類(lèi)型:

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

向量的分量訪(fǎng)問(wèn):

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

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);

運(yùn)算符:

ps 左值與右值:

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

右值:表示一個(gè)值, 可以是一個(gè)變量或者表達(dá)式再或者純粹的值.

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

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

基礎(chǔ)類(lèi)型間的運(yùn)算:

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

int a =2.0; //錯(cuò)誤,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;

下面來(lái)分別說(shuō)說(shuō)可能遇到的情況:

1.float 與 int:

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

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這些類(lèi)型其實(shí)是由float復(fù)合而成的,當(dāng)它們與float運(yùn)算時(shí),其實(shí)就是在每一個(gè)分量上分別與float進(jìn)行運(yùn)算,這就是所謂的逐分量運(yùn)算.glsl里
大部分涉及vec,mat的運(yùn)算都是逐分量運(yùn)算,但也并不全是. 下文中就會(huì)講到特例.

逐分量運(yùn)算是線(xiàn)性的,這就是說(shuō) vec 與 float 的運(yùn)算結(jié)果是還是 vec.

int 與 vec,mat之間是不可運(yùn)算的, 因?yàn)関ec和mat中的每一個(gè)分量都是 float 類(lèi)型的. 無(wú)法與int進(jìn)行逐分量計(jì)算.

下面枚舉了幾種 float 與 vec,mat 運(yùn)算的情況

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(向量):

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

它們的計(jì)算方式是兩操作數(shù)在同位置上的分量分別進(jìn)行運(yùn)算,其本質(zhì)還是逐分量進(jìn)行的,這和上面所說(shuō)的float類(lèi)型的
逐分量運(yùn)算可能有一點(diǎn)點(diǎn)差異,相同的是 vec 與 vec 運(yùn)算結(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間只存在乘法運(yùn)算.

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

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的運(yùn)算中, 除了乘法是線(xiàn)性代數(shù)中的矩陣乘法外.其余的運(yùn)算任為逐分量運(yùn)算.簡(jiǎn)單說(shuō)就是只有乘法是特殊的,其余都和vec與vec運(yùn)算類(lèi)似.

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語(yǔ)言類(lèi)似,被const限定符修飾的變量初始化后不可變,除了局部變量,函數(shù)參數(shù)也可以使用const修飾符.但要注意的是結(jié)構(gòu)變量可以用const修飾,
但結(jié)構(gòu)中的字段不行.

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

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

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

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

attribute:

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

attribute vec4 a_Position;

uniform:

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

uniform vec4 lightPosition;

varying:

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

//頂點(diǎn)著色器
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中的一個(gè).不可復(fù)合.

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

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

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

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

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

glsl的函數(shù):

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

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中變量可以在聲明的時(shí)候初始化,float pSize = 10.0 也可以先聲明然后等需要的時(shí)候在進(jìn)行賦值.

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

//一般類(lèi)型
float pSize = 10.0;
float pSize1;
pSize1=10.0;
...

//復(fù)合類(lèi)型
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);

類(lèi)型轉(zhuǎn)換:

glsl可以使用構(gòu)造函數(shù)進(jìn)行顯式類(lèi)型轉(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在進(jìn)行光柵化著色的時(shí)候,會(huì)產(chǎn)生大量的浮點(diǎn)數(shù)運(yùn)算,這些運(yùn)算可能是當(dāng)前設(shè)備所不能承受的,所以glsl提供了3種浮點(diǎn)數(shù)精度,我們可以根據(jù)不同的設(shè)備來(lái)使用合適的精度.

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

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

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

如何確定精度:

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

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

invariant關(guān)鍵字:

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

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

限定符的順序:

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

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

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

我們來(lái)舉例說(shuō)明:

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

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

預(yù)編譯指令:

以 # 開(kāi)頭的是預(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)進(jìn)行編譯,如果使用這條預(yù)編譯指令,則他必須出現(xiàn)在程序的最開(kāi)始位置.

內(nèi)置的宏:

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

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

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

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

實(shí)例:

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

#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)置變量與硬件進(jìn)行溝通.他們大致分成兩種 一種是 input類(lèi)型,他負(fù)責(zé)向硬件(渲染管線(xiàn))發(fā)送數(shù)據(jù).
另一種是output類(lèi)型,負(fù)責(zé)向程序回傳數(shù)據(jù),以便編程時(shí)需要.

在 vertex Shader 中:

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

在 fragment Shader 中:

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

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

內(nèi)置的常量

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

在 vertex Shader 中:

1.const mediump int gl_MaxVertexAttribs>=8

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

2.const mediump int gl_MaxVertexUniformVectors >= 128

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

3.const mediump int gl_MaxVaryingVectors >= 8

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

4.const mediump int gl_MaxVertexTextureImageUnits >= 0

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

5.const mediump int gl_MaxCombinedTextureImageUnits >= 8

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

在 fragment Shader 中:

1.const mediump int gl_MaxTextureImageUnits >= 8

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

2.const mediump int gl_MaxFragmentUniformVectors >= 16

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

3.const mediump int gl_MaxDrawBuffers = 1

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

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

結(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語(yǔ)言非常相似,這里不必再做過(guò)多說(shuō)明,唯一不同的是片段著色器中有一種特殊的控制流discard.
使用discard會(huì)退出片段著色器，不執(zhí)行后面的片段著色操作。片段也不會(huì)寫(xiě)入幀緩沖區(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ù)庫(kù)

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

通用函數(shù):

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

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

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

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

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

幾何函數(shù):

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

矩陣函數(shù):

mat可以為任意類(lèi)型矩陣.

向量函數(shù):

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

bvec指的是由bool類(lèi)型組成的一個(gè)向量:

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

紋理查詢(xún)函數(shù):

圖像紋理有兩種 一種是平面2d紋理,另一種是盒紋理,針對(duì)不同的紋理類(lèi)型有不同訪(fǎng)問(wèn)方法.

紋理查詢(xún)的最終目的是從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如果你可以一眼看懂,說(shuō)明你已經(jīng)對(duì)glsl語(yǔ)言基本掌握了.

Vertex Shader:

uniform mat4 mvp_matrix; //透視矩陣 * 視圖矩陣 * 模型變換矩陣
uniform mat3 normal_matrix; //法線(xiàn)變換矩陣(用于物體變換后法線(xiàn)跟著變換)
uniform vec3 ec_light_dir; //光照方向
attribute vec4 a_vertex; // 頂點(diǎn)坐標(biāo)
attribute vec3 a_normal; //頂點(diǎn)法線(xiàn)
attribute vec2 a_texcoord; //紋理坐標(biāo)
varying float v_diffuse; //法線(xiàn)與入射光的夾角
varying vec2 v_texcoord; //2d紋理坐標(biāo)
void main(void)
{
 //歸一化法線(xiàn)
 vec3 ec_normal = normalize(normal_matrix * a_normal);
 //v_diffuse 是法線(xiàn)與光照的夾角.根據(jù)向量點(diǎn)乘法則,當(dāng)兩向量長(zhǎ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);
 //這里分解開(kāi)來(lái)是 color*vec3(1,1,1)*v_diffuse + color*i_ambient
 //色*光*夾角cos + 色*環(huán)境光
 gl_FragColor = color*(vec4(v_diffuse) + i_ambient);
}