版本記錄

前言

OpenGL 圖形庫(kù)項(xiàng)目中一直也沒用過更鲁，最近也想學(xué)著使用這個(gè)圖形庫(kù)漫试，感覺還是很有意思隙笆，也就自然想著好好的總結(jié)一下蛾号，希望對(duì)大家能有所幫助稠项。下面內(nèi)容來自歡迎來到OpenGL的世界。
1. OpenGL 圖形庫(kù)使用（一） —— 概念基礎(chǔ)
2. OpenGL 圖形庫(kù)使用（二） —— 渲染模式鲜结、對(duì)象展运、擴(kuò)展和狀態(tài)機(jī)
3. OpenGL 圖形庫(kù)使用（三） —— 著色器、數(shù)據(jù)類型與輸入輸出
4. OpenGL 圖形庫(kù)使用（四） —— Uniform及更多屬性
5. OpenGL 圖形庫(kù)使用（五） —— 紋理
6. OpenGL 圖形庫(kù)使用（六） —— 變換
7. OpenGL 圖形庫(kù)的使用（七）—— 坐標(biāo)系統(tǒng)之五種不同的坐標(biāo)系統(tǒng)（一）
8. OpenGL 圖形庫(kù)的使用（八）—— 坐標(biāo)系統(tǒng)之3D效果（二）
9. OpenGL 圖形庫(kù)的使用（九）—— 攝像機(jī)（一）
10. OpenGL 圖形庫(kù)的使用（十）—— 攝像機(jī)（二）
11. OpenGL 圖形庫(kù)的使用（十一）—— 光照之顏色
12. OpenGL 圖形庫(kù)的使用（十二）—— 光照之基礎(chǔ)光照
13. OpenGL 圖形庫(kù)的使用（十三）—— 光照之材質(zhì)
14. OpenGL 圖形庫(kù)的使用（十四）—— 光照之光照貼圖
15. OpenGL 圖形庫(kù)的使用（十五）—— 光照之投光物
16. OpenGL 圖形庫(kù)的使用（十六）—— 光照之多光源
17. OpenGL 圖形庫(kù)的使用（十七）—— 光照之復(fù)習(xí)總結(jié)
18. OpenGL 圖形庫(kù)的使用（十八）—— 模型加載之Assimp
19. OpenGL 圖形庫(kù)的使用（十九）—— 模型加載之網(wǎng)格
20. OpenGL 圖形庫(kù)的使用（二十）—— 模型加載之模型
21. OpenGL 圖形庫(kù)的使用（二十一）—— 高級(jí)OpenGL之深度測(cè)試
22. OpenGL 圖形庫(kù)的使用（二十二）—— 高級(jí)OpenGL之模板測(cè)試Stencil testing
23. OpenGL 圖形庫(kù)的使用（二十三）—— 高級(jí)OpenGL之混合Blending
24. OpenGL 圖形庫(kù)的使用（二十四）—— 高級(jí)OpenGL之面剔除Face culling
25. OpenGL 圖形庫(kù)的使用（二十五）—— 高級(jí)OpenGL之幀緩沖Framebuffers
26. OpenGL 圖形庫(kù)的使用（二十六）—— 高級(jí)OpenGL之立方體貼圖Cubemaps
27. OpenGL 圖形庫(kù)的使用（二十七）—— 高級(jí)OpenGL之高級(jí)數(shù)據(jù)Advanced Data

高級(jí)GLSL

這一小節(jié)并不會(huì)向你展示非常先進(jìn)非尘ⅲ酷的新特性拗胜，也不會(huì)對(duì)場(chǎng)景的視覺質(zhì)量有顯著的提高。但是怒允，這一節(jié)會(huì)或多或少涉及GLSL的一些有趣的地方以及一些很棒的技巧埂软，它們可能在今后會(huì)幫助到你。簡(jiǎn)單來說纫事，它們就是在組合使用OpenGL和GLSL創(chuàng)建程序時(shí)的一些最好要知道的東西勘畔，和一些會(huì)讓你生活更加輕松的特性所灸。

我們將會(huì)討論一些有趣的內(nèi)建變量(Built-in Variable)，管理著色器輸入和輸出的新方式以及一個(gè)叫做Uniform緩沖對(duì)象(Uniform Buffer Object)的有用工具炫七。

GLSL的內(nèi)建變量

著色器都是最簡(jiǎn)化的爬立，如果需要當(dāng)前著色器以外地方的數(shù)據(jù)的話，我們必須要將數(shù)據(jù)傳進(jìn)來万哪。我們已經(jīng)學(xué)會(huì)使用頂點(diǎn)屬性侠驯、uniform和采樣器來完成這一任務(wù)了。然而奕巍，除此之外陵霉，GLSL還定義了另外幾個(gè)以gl_為前綴的變量，它們能提供給我們更多的方式來讀取/寫入數(shù)據(jù)伍绳。我們已經(jīng)在前面教程中接觸過其中的兩個(gè)了：頂點(diǎn)著色器的輸出向量gl_Position，和片段著色器的gl_FragCoord乍桂。

我們將會(huì)討論幾個(gè)有趣的GLSL內(nèi)建輸入和輸出變量冲杀，并會(huì)解釋它們能夠怎樣幫助你。注意睹酌，我們將不會(huì)討論GLSL中存在的所有內(nèi)建變量权谁，如果你想知道所有的內(nèi)建變量的話，請(qǐng)查看OpenGL的wiki憋沿。

頂點(diǎn)著色器變量

我們已經(jīng)見過gl_Position了旺芽，它是頂點(diǎn)著色器的裁剪空間輸出位置向量。如果你想在屏幕上顯示任何東西辐啄，在頂點(diǎn)著色器中設(shè)置gl_Position是必須的步驟采章。這已經(jīng)是它的全部功能了。

1. gl_PointSize

我們能夠選用的其中一個(gè)圖元是GL_POINTS壶辜，如果使用它的話悯舟，每一個(gè)頂點(diǎn)都是一個(gè)圖元，都會(huì)被渲染為一個(gè)點(diǎn)砸民。我們可以通過OpenGL的glPointSize函數(shù)來設(shè)置渲染出來的點(diǎn)的大小抵怎，但我們也可以在頂點(diǎn)著色器中修改這個(gè)值。

GLSL定義了一個(gè)叫做gl_PointSize輸出變量岭参，它是一個(gè)float變量反惕，你可以使用它來設(shè)置點(diǎn)的寬高（像素）。在頂點(diǎn)著色器中修改點(diǎn)的大小的話演侯，你就能對(duì)每個(gè)頂點(diǎn)設(shè)置不同的值了姿染。

在頂點(diǎn)著色器中修改點(diǎn)大小的功能默認(rèn)是禁用的，如果你需要啟用它的話秒际，你需要啟用OpenGL的GL_PROGRAM_POINT_SIZE：

glEnable(GL_PROGRAM_POINT_SIZE);

一個(gè)簡(jiǎn)單的例子就是將點(diǎn)的大小設(shè)置為裁剪空間位置的z值盔粹，也就是頂點(diǎn)距觀察者的距離隘梨。點(diǎn)的大小會(huì)隨著觀察者距頂點(diǎn)距離變遠(yuǎn)而增大。

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);    
    gl_PointSize = gl_Position.z;    
}

結(jié)果就是舷嗡，當(dāng)我們遠(yuǎn)離這些點(diǎn)的時(shí)候轴猎，它們會(huì)變得更大：

你可以想到，對(duì)每個(gè)頂點(diǎn)使用不同的點(diǎn)大小进萄，會(huì)在粒子生成之類的技術(shù)中很有意思捻脖。

2. gl_VertexID

gl_Position和gl_PointSize都是輸出變量，因?yàn)樗鼈兊闹凳亲鳛轫旤c(diǎn)著色器的輸出被讀取的中鼠。我們可以對(duì)它們進(jìn)行寫入可婶，來改變結(jié)果。頂點(diǎn)著色器還為我們提供了一個(gè)有趣的輸入變量援雇，我們只能對(duì)它進(jìn)行讀取矛渴，它叫做gl_VertexID。

整型變量gl_VertexID儲(chǔ)存了正在繪制頂點(diǎn)的當(dāng)前ID惫搏。當(dāng)（使用glDrawElements）進(jìn)行索引渲染的時(shí)候具温，這個(gè)變量會(huì)存儲(chǔ)正在繪制頂點(diǎn)的當(dāng)前索引。當(dāng)（使用glDrawArrays）不使用索引進(jìn)行繪制的時(shí)候筐赔，這個(gè)變量會(huì)儲(chǔ)存從渲染調(diào)用開始的已處理頂點(diǎn)數(shù)量铣猩。

雖然現(xiàn)在它沒有什么具體的用途，但知道我們能夠訪問這個(gè)信息總是好的茴丰。

片段著色器變量

在片段著色器中达皿，我們也能訪問到一些有趣的變量。GLSL提供給我們兩個(gè)有趣的輸入變量：gl_FragCoord和gl_FrontFacing贿肩。

1. gl_FragCoord

在討論深度測(cè)試的時(shí)候峦椰，我們已經(jīng)見過gl_FragCoord很多次了，因?yàn)?code>gl_FragCoord的z分量等于對(duì)應(yīng)片段的深度值汰规。然而们何，我們也能使用它的x和y分量來實(shí)現(xiàn)一些有趣的效果。

gl_FragCoord的x和y分量是片段的窗口空間(Window-space)坐標(biāo)控轿，其原點(diǎn)為窗口的左下角冤竹。我們已經(jīng)使用glViewport設(shè)定了一個(gè)800x600的窗口了，所以片段窗口空間坐標(biāo)的x分量將在0到800之間茬射，y分量在0到600之間鹦蠕。

通過利用片段著色器，我們可以根據(jù)片段的窗口坐標(biāo)在抛，計(jì)算出不同的顏色钟病。gl_FragCoord的一個(gè)常見用處是用于對(duì)比不同片段計(jì)算的視覺輸出效果，這在技術(shù)演示中可以經(jīng)常看到肠阱。比如說票唆，我們能夠?qū)⑵聊环殖蓛刹糠郑诖翱诘淖髠?cè)渲染一種輸出屹徘，在窗口的右側(cè)渲染另一種輸出走趋。下面這個(gè)例子片段著色器會(huì)根據(jù)窗口坐標(biāo)輸出不同的顏色：

void main()
{             
    if(gl_FragCoord.x < 400)
        FragColor = vec4(1.0, 0.0, 0.0, 1.0);
    else
        FragColor = vec4(0.0, 1.0, 0.0, 1.0);        
}

因?yàn)榇翱诘膶挾仁?00。當(dāng)一個(gè)像素的x坐標(biāo)小于400時(shí)噪伊，它一定在窗口的左側(cè)簿煌，所以我們給它一個(gè)不同的顏色。

我們現(xiàn)在會(huì)計(jì)算出兩個(gè)完全不同的片段著色器結(jié)果鉴吹，并將它們顯示在窗口的兩側(cè)姨伟。舉例來說，你可以將它用于測(cè)試不同的光照技巧豆励。

2. gl_FrontFacing

片段著色器另外一個(gè)很有意思的輸入變量是gl_FrontFacing夺荒。在面剔除教程中，我們提到OpenGL能夠根據(jù)頂點(diǎn)的環(huán)繞順序來決定一個(gè)面是正向還是背向面良蒸。如果我們不（啟用GL_FACE_CULL來）使用面剔除技扼，那么gl_FrontFacing將會(huì)告訴我們當(dāng)前片段是屬于正向面的一部分還是背向面的一部分。舉例來說诚啃，我們能夠?qū)φ蛎嬗?jì)算出不同的顏色。

gl_FrontFacing變量是一個(gè)bool私沮，如果當(dāng)前片段是正向面的一部分那么就是true始赎，否則就是false。比如說仔燕，我們可以這樣子創(chuàng)建一個(gè)立方體造垛，在內(nèi)部和外部使用不同的紋理：

#version 330 core
out vec4 FragColor;

in vec2 TexCoords;

uniform sampler2D frontTexture;
uniform sampler2D backTexture;

void main()
{             
    if(gl_FrontFacing)
        FragColor = texture(frontTexture, TexCoords);
    else
        FragColor = texture(backTexture, TexCoords);
}

如果我們往箱子里面看，就能看到使用的是不同的紋理晰搀。

注意五辽，如果你開啟了面剔除，你就看不到箱子內(nèi)部的面了外恕，所以現(xiàn)在再使用gl_FrontFacing就沒有意義了杆逗。

3. gl_FragDepth

輸入變量gl_FragCoord能讓我們讀取當(dāng)前片段的窗口空間坐標(biāo)，并獲取它的深度值鳞疲，但是它是一個(gè)只讀(Read-only)變量罪郊。我們不能修改片段的窗口空間坐標(biāo)，但實(shí)際上修改片段的深度值還是可能的尚洽。GLSL提供給我們一個(gè)叫做gl_FragDepth的輸出變量悔橄，我們可以使用它來在著色器內(nèi)設(shè)置片段的深度值。

要想設(shè)置深度值，我們直接寫入一個(gè)0.0到1.0之間的float值到輸出變量就可以了：

gl_FragDepth = 0.0; // 這個(gè)片段現(xiàn)在的深度值為 0.0

如果著色器沒有寫入值到gl_FragDepth癣疟，它會(huì)自動(dòng)取用gl_FragCoord.z的值挣柬。

然而，由我們自己設(shè)置深度值有一個(gè)很大的缺點(diǎn)睛挚，只要我們?cè)谄沃髦袑?duì)gl_FragDepth進(jìn)行寫入邪蛔，OpenGL就會(huì)（像深度測(cè)試小節(jié)中討論的那樣）禁用所有的提前深度測(cè)試(Early Depth Testing)。它被禁用的原因是竞川，OpenGL無法在片段著色器運(yùn)行之前得知片段將擁有的深度值店溢，因?yàn)槠沃骺赡軙?huì)完全修改這個(gè)深度值。

在寫入gl_FragDepth時(shí)委乌，你就需要考慮到它所帶來的性能影響床牧。然而，從OpenGL 4.2起遭贸，我們?nèi)钥梢詫?duì)兩者進(jìn)行一定的調(diào)和戈咳，在片段著色器的頂部使用深度條件(Depth Condition)重新聲明gl_FragDepth變量：

layout (depth_<condition>) out float gl_FragDepth;

condition可以為下面的值：

通過將深度條件設(shè)置為greater或者less，OpenGL就能假設(shè)你只會(huì)寫入比當(dāng)前片段深度值更大或者更小的值了壕吹。這樣子的話著蛙，當(dāng)深度值比片段的深度值要小的時(shí)候，OpenGL仍是能夠進(jìn)行提前深度測(cè)試的耳贬。

下面這個(gè)例子中踏堡，我們對(duì)片段的深度值進(jìn)行了遞增，但仍然也保留了一些提前深度測(cè)試：

#version 420 core // 注意GLSL的版本咒劲！
out vec4 FragColor;
layout (depth_greater) out float gl_FragDepth;

void main()
{             
    FragColor = vec4(1.0);
    gl_FragDepth = gl_FragCoord.z + 0.1;
}  

注意這個(gè)特性只在OpenGL 4.2版本或以上才提供顷蟆。

接口塊

到目前為止，每當(dāng)我們希望從頂點(diǎn)著色器向片段著色器發(fā)送數(shù)據(jù)時(shí)腐魂，我們都聲明了幾個(gè)對(duì)應(yīng)的輸入/輸出變量帐偎。將它們一個(gè)一個(gè)聲明是著色器間發(fā)送數(shù)據(jù)最簡(jiǎn)單的方式了，但當(dāng)程序變得更大時(shí)蛔屹，你希望發(fā)送的可能就不只是幾個(gè)變量了削樊，它還可能包括數(shù)組和結(jié)構(gòu)體。

為了幫助我們管理這些變量兔毒，GLSL為我們提供了一個(gè)叫做接口塊(Interface Block)的東西漫贞，來方便我們組合這些變量。接口塊的聲明和struct的聲明有點(diǎn)相像育叁，不同的是绕辖，現(xiàn)在根據(jù)它是一個(gè)輸入還是輸出塊(Block)，使用in或out關(guān)鍵字來定義的擂红。

#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoords;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out VS_OUT
{
    vec2 TexCoords;
} vs_out;

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);    
    vs_out.TexCoords = aTexCoords;
}  

這次我們聲明了一個(gè)叫做vs_out的接口塊仪际，它打包了我們希望發(fā)送到下一個(gè)著色器中的所有輸出變量围小。這只是一個(gè)很簡(jiǎn)單的例子，但你可以想象一下树碱，它能夠幫助你管理著色器的輸入和輸出肯适。當(dāng)我們希望將著色器的輸入或輸出打包為數(shù)組時(shí)，它也會(huì)非常有用成榜，我們將在下一節(jié)討論幾何著色器(Geometry Shader)時(shí)見到框舔。

之后，我們還需要在下一個(gè)著色器赎婚，即片段著色器刘绣，中定義一個(gè)輸入接口塊。塊名(Block Name)應(yīng)該是和著色器中一樣的VS_OUT挣输，但實(shí)例名(Instance Name)（頂點(diǎn)著色器中用的是vs_out）可以是隨意的纬凤，但要避免使用誤導(dǎo)性的名稱，比如對(duì)實(shí)際上包含輸入變量的接口塊命名為vs_out撩嚼。

#version 330 core
out vec4 FragColor;

in VS_OUT
{
    vec2 TexCoords;
} fs_in;

uniform sampler2D texture;

void main()
{             
    FragColor = texture(texture, fs_in.TexCoords);   
}

只要兩個(gè)接口塊的名字一樣停士，它們對(duì)應(yīng)的輸入和輸出將會(huì)匹配起來。這是幫助你管理代碼的又一個(gè)有用特性完丽，它在幾何著色器這樣穿插特定著色器階段的場(chǎng)景下會(huì)很有用恋技。

Uniform緩沖對(duì)象

我們已經(jīng)使用OpenGL很長(zhǎng)時(shí)間了，學(xué)會(huì)了一些很酷的技巧逻族，但也遇到了一些很麻煩的地方蜻底。比如說，當(dāng)使用多余一個(gè)的著色器時(shí)聘鳞，盡管大部分的uniform變量都是相同的薄辅，我們還是需要不斷地設(shè)置它們，所以為什么要這么麻煩地重復(fù)設(shè)置它們呢搁痛？

OpenGL為我們提供了一個(gè)叫做Uniform緩沖對(duì)象(Uniform Buffer Object)的工具长搀，它允許我們定義一系列在多個(gè)著色器中相同的全局Uniform變量宇弛。當(dāng)使用Uniform緩沖對(duì)象的時(shí)候鸡典，我們只需要設(shè)置相關(guān)的uniform一次。當(dāng)然枪芒，我們?nèi)孕枰謩?dòng)設(shè)置每個(gè)著色器中不同的uniform彻况。并且創(chuàng)建和配置Uniform緩沖對(duì)象會(huì)有一點(diǎn)繁瑣。

因?yàn)閁niform緩沖對(duì)象仍是一個(gè)緩沖舅踪，我們可以使用glGenBuffers來創(chuàng)建它纽甘，將它綁定到GL_UNIFORM_BUFFER緩沖目標(biāo)，并將所有相關(guān)的uniform數(shù)據(jù)存入緩沖抽碌。在Uniform緩沖對(duì)象中儲(chǔ)存數(shù)據(jù)是有一些規(guī)則的悍赢，我們將會(huì)在之后討論它。首先，我們將使用一個(gè)簡(jiǎn)單的頂點(diǎn)著色器左权，將projection和view矩陣存儲(chǔ)到所謂的Uniform塊(Uniform Block)中：

#version 330 core
layout (location = 0) in vec3 aPos;

layout (std140) uniform Matrices
{
    mat4 projection;
    mat4 view;
};

uniform mat4 model;

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
}

在我們大多數(shù)的例子中皮胡，我們都會(huì)在每個(gè)渲染迭代中，對(duì)每個(gè)著色器設(shè)置projection和view Uniform矩陣赏迟。這是利用Uniform緩沖對(duì)象的一個(gè)非常完美的例子屡贺，因?yàn)楝F(xiàn)在我們只需要存儲(chǔ)這些矩陣一次就可以了。

這里锌杀，我們聲明了一個(gè)叫做Matrices的Uniform塊甩栈，它儲(chǔ)存了兩個(gè)4x4矩陣。Uniform塊中的變量可以直接訪問糕再，不需要加塊名作為前綴量没。接下來，我們?cè)贠penGL代碼中將這些矩陣值存入緩沖中亿鲜，每個(gè)聲明了這個(gè)Uniform塊的著色器都能夠訪問這些矩陣允蜈。

你現(xiàn)在可能會(huì)在想layout (std140)這個(gè)語句是什么意思。它的意思是說蒿柳，當(dāng)前定義的Uniform塊對(duì)它的內(nèi)容使用一個(gè)特定的內(nèi)存布局饶套。這個(gè)語句設(shè)置了Uniform塊布局(Uniform Block Layout)。

Uniform塊布局

Uniform塊的內(nèi)容是儲(chǔ)存在一個(gè)緩沖對(duì)象中的垒探，它實(shí)際上只是一塊預(yù)留內(nèi)存妓蛮。因?yàn)檫@塊內(nèi)存并不會(huì)保存它具體保存的是什么類型的數(shù)據(jù)，我們還需要告訴OpenGL內(nèi)存的哪一部分對(duì)應(yīng)著著色器中的哪一個(gè)uniform變量圾叼。

假設(shè)著色器中有以下的這個(gè)Uniform塊：

layout (std140) uniform ExampleBlock
{
    float value;
    vec3  vector;
    mat4  matrix;
    float values[3];
    bool  boolean;
    int   integer;
};

我們需要知道的是每個(gè)變量的大懈蚩恕（字節(jié)）和（從塊起始位置的）偏移量，來讓我們能夠按順序?qū)⑺鼈兎胚M(jìn)緩沖中夷蚊。每個(gè)元素的大小都是在OpenGL中有清楚地聲明的构挤，而且直接對(duì)應(yīng)C++數(shù)據(jù)類型，其中向量和矩陣都是大的float數(shù)組惕鼓。OpenGL沒有聲明的是這些變量間的間距(Spacing)筋现。這允許硬件能夠在它認(rèn)為合適的位置放置變量。比如說箱歧，一些硬件可能會(huì)將一個(gè)vec3放置在float邊上矾飞。不是所有的硬件都能這樣處理，可能會(huì)在附加這個(gè)float之前呀邢，先將vec3填充(Pad)為一個(gè)4個(gè)float的數(shù)組洒沦。這個(gè)特性本身很棒，但是會(huì)對(duì)我們?cè)斐陕闊?/p>

默認(rèn)情況下价淌，GLSL會(huì)使用一個(gè)叫做共享(Shared)布局的Uniform內(nèi)存布局申眼，共享是因?yàn)橐坏┯布x了偏移量瞒津，它們?cè)诙鄠€(gè)程序中是共享并一致的。使用共享布局時(shí)括尸，GLSL是可以為了優(yōu)化而對(duì)uniform變量的位置進(jìn)行變動(dòng)的仲智，只要變量的順序保持不變。因?yàn)槲覀儫o法知道每個(gè)uniform變量的偏移量姻氨，我們也就不知道如何準(zhǔn)確地填充我們的Uniform緩沖了钓辆。我們能夠使用像是glGetUniformIndices這樣的函數(shù)來查詢這個(gè)信息，但這超出本節(jié)的范圍了肴焊。

雖然共享布局給了我們很多節(jié)省空間的優(yōu)化前联，但是我們需要查詢每個(gè)uniform變量的偏移量，這會(huì)產(chǎn)生非常多的工作量娶眷。通常的做法是似嗤，不使用共享布局，而是使用std140布局届宠。std140布局聲明了每個(gè)變量的偏移量都是由一系列規(guī)則所決定的烁落，這顯式地聲明了每個(gè)變量類型的內(nèi)存布局。由于這是顯式提及的豌注，我們可以手動(dòng)計(jì)算出每個(gè)變量的偏移量伤塌。

每個(gè)變量都有一個(gè)基準(zhǔn)對(duì)齊量(Base Alignment)，它等于一個(gè)變量在Uniform塊中所占據(jù)的空間（包括填充量(Padding)）轧铁，這個(gè)基準(zhǔn)對(duì)齊量是使用std140布局的規(guī)則計(jì)算出來的每聪。接下來，對(duì)每個(gè)變量齿风，我們?cè)儆?jì)算它的對(duì)齊偏移量(Aligned Offset)药薯，它是一個(gè)變量從塊起始位置的字節(jié)偏移量。一個(gè)變量的對(duì)齊字節(jié)偏移量必須等于基準(zhǔn)對(duì)齊量的倍數(shù)救斑。

布局規(guī)則的原文可以在OpenGL的Uniform緩沖規(guī)范這里找到童本，但我們將會(huì)在下面列出最常見的規(guī)則。GLSL中的每個(gè)變量脸候，比如說int穷娱、float和bool，都被定義為4字節(jié)量纪他。每4個(gè)字節(jié)將會(huì)用一個(gè)N來表示鄙煤。

和OpenGL大多數(shù)的規(guī)范一樣晾匠，使用例子就能更容易地理解茶袒。我們會(huì)使用之前引入的那個(gè)叫做ExampleBlock的Uniform塊，并使用std140布局計(jì)算出每個(gè)成員的對(duì)齊偏移量：

layout (std140) uniform ExampleBlock
{
                     // 基準(zhǔn)對(duì)齊量       // 對(duì)齊偏移量
    float value;     // 4               // 0 
    vec3 vector;     // 16              // 16  (必須是16的倍數(shù)凉馆，所以 4->16)
    mat4 matrix;     // 16              // 32  (列 0)
                     // 16              // 48  (列 1)
                     // 16              // 64  (列 2)
                     // 16              // 80  (列 3)
    float values[3]; // 16              // 96  (values[0])
                     // 16              // 112 (values[1])
                     // 16              // 128 (values[2])
    bool boolean;    // 4               // 144
    int integer;     // 4               // 148
}; 

作為練習(xí)薪寓，嘗試去自己計(jì)算一下偏移量亡资，并和表格進(jìn)行對(duì)比。使用計(jì)算后的偏移量值向叉，根據(jù)std140布局的規(guī)則锥腻，我們就能使用像是glBufferSubData的函數(shù)將變量數(shù)據(jù)按照偏移量填充進(jìn)緩沖中了。雖然std140布局不是最高效的布局母谎，但它保證了內(nèi)存布局在每個(gè)聲明了這個(gè)Uniform塊的程序中是一致的瘦黑。

通過在Uniform塊定義之前添加layout (std140)語句，我們告訴OpenGL這個(gè)Uniform塊使用的是std140布局奇唤。除此之外還可以選擇兩個(gè)布局幸斥，但它們都需要我們?cè)谔畛渚彌_之前先查詢每個(gè)偏移量。我們已經(jīng)見過shared布局了咬扇，剩下的一個(gè)布局是packed甲葬。當(dāng)使用緊湊(Packed)布局時(shí)，是不能保證這個(gè)布局在每個(gè)程序中保持不變的（即非共享）懈贺，因?yàn)樗试S編譯器去將uniform變量從Uniform塊中優(yōu)化掉经窖，這在每個(gè)著色器中都可能是不同的。

使用Uniform緩沖

我們已經(jīng)討論了如何在著色器中定義Uniform塊梭灿，并設(shè)定它們的內(nèi)存布局了画侣，但我們還沒有討論該如何使用它們。

首先堡妒，我們需要調(diào)用glGenBuffers棉钧，創(chuàng)建一個(gè)Uniform緩沖對(duì)象。一旦我們有了一個(gè)緩沖對(duì)象涕蚤，我們需要將它綁定到GL_UNIFORM_BUFFER目標(biāo)宪卿，并調(diào)用glBufferData，分配足夠的內(nèi)存万栅。

unsigned int uboExampleBlock;
glGenBuffers(1, &uboExampleBlock);
glBindBuffer(GL_UNIFORM_BUFFER, uboExampleBlock);
glBufferData(GL_UNIFORM_BUFFER, 152, NULL, GL_STATIC_DRAW); // 分配152字節(jié)的內(nèi)存
glBindBuffer(GL_UNIFORM_BUFFER, 0);

現(xiàn)在佑钾，每當(dāng)我們需要對(duì)緩沖更新或者插入數(shù)據(jù)，我們都會(huì)綁定到uboExampleBlock烦粒，并使用glBufferSubData來更新它的內(nèi)存休溶。我們只需要更新這個(gè)Uniform緩沖一次，所有使用這個(gè)緩沖的著色器就都使用的是更新后的數(shù)據(jù)了扰她。但是兽掰，如何才能讓OpenGL知道哪個(gè)Uniform緩沖對(duì)應(yīng)的是哪個(gè)Uniform塊呢？

在OpenGL上下文中徒役，定義了一些綁定點(diǎn)(Binding Point)孽尽，我們可以將一個(gè)Uniform緩沖鏈接至它。在創(chuàng)建Uniform緩沖之后忧勿，我們將它綁定到其中一個(gè)綁定點(diǎn)上杉女，并將著色器中的Uniform塊綁定到相同的綁定點(diǎn)瞻讽，把它們連接到一起。下面的這個(gè)圖示展示了這個(gè)：

你可以看到熏挎，我們可以綁定多個(gè)Uniform緩沖到不同的綁定點(diǎn)上速勇。因?yàn)橹鰽和著色器B都有一個(gè)鏈接到綁定點(diǎn)0的Uniform塊，它們的Uniform塊將會(huì)共享相同的uniform數(shù)據(jù)坎拐，uboMatrices烦磁，前提條件是兩個(gè)著色器都定義了相同的Matrices Uniform塊。

為了將Uniform塊綁定到一個(gè)特定的綁定點(diǎn)中哼勇，我們需要調(diào)用glUniformBlockBinding函數(shù)个初，它的第一個(gè)參數(shù)是一個(gè)程序?qū)ο螅笫且粋€(gè)Uniform塊索引和鏈接到的綁定點(diǎn)猴蹂。Uniform塊索引(Uniform Block Index)是著色器中已定義Uniform塊的位置值索引院溺。這可以通過調(diào)用glGetUniformBlockIndex來獲取，它接受一個(gè)程序?qū)ο蠛蚒niform塊的名稱磅轻。我們可以用以下方式將圖示中的Lights Uniform塊鏈接到綁定點(diǎn)2：

unsigned int lights_index = glGetUniformBlockIndex(shaderA.ID, "Lights");   
glUniformBlockBinding(shaderA.ID, lights_index, 2);

注意我們需要對(duì)每個(gè)著色器重復(fù)這一步驟珍逸。

從OpenGL 4.2版本起，你也可以添加一個(gè)布局標(biāo)識(shí)符聋溜，顯式地將Uniform塊的綁定點(diǎn)儲(chǔ)存在著色器中谆膳，這樣就不用再調(diào)用glGetUniformBlockIndex和glUniformBlockBinding了。下面的代碼顯式地設(shè)置了Lights Uniform塊的綁定點(diǎn)撮躁。

layout(std140, binding = 2) uniform Lights { ... };

接下來漱病，我們還需要綁定Uniform緩沖對(duì)象到相同的綁定點(diǎn)上，這可以使用glBindBufferBase或glBindBufferRange來完成把曼。

glBindBufferBase(GL_UNIFORM_BUFFER, 2, uboExampleBlock); 
// 或
glBindBufferRange(GL_UNIFORM_BUFFER, 2, uboExampleBlock, 0, 152);

glBindbufferBase需要一個(gè)目標(biāo)杨帽，一個(gè)綁定點(diǎn)索引和一個(gè)Uniform緩沖對(duì)象作為它的參數(shù)。這個(gè)函數(shù)將uboExampleBlock鏈接到綁定點(diǎn)2上嗤军，自此注盈，綁定點(diǎn)的兩端都鏈接上了。你也可以使用glBindBufferRange函數(shù)叙赚，它需要一個(gè)附加的偏移量和大小參數(shù)老客，這樣子你可以綁定Uniform緩沖的特定一部分到綁定點(diǎn)中。通過使用glBindBufferRange函數(shù)胧砰，你可以讓多個(gè)不同的Uniform塊綁定到同一個(gè)Uniform緩沖對(duì)象上。

現(xiàn)在乌妒，所有的東西都配置完畢了，我們可以開始向Uniform緩沖中添加數(shù)據(jù)了外邓。只要我們需要撤蚊，就可以使用glBufferSubData函數(shù)，用一個(gè)字節(jié)數(shù)組添加所有的數(shù)據(jù)损话，或者更新緩沖的一部分侦啸。要想更新uniform變量boolean，我們可以用以下方式更新Uniform緩沖對(duì)象：

glBindBuffer(GL_UNIFORM_BUFFER, uboExampleBlock);
int b = true; // GLSL中的bool是4字節(jié)的丧枪，所以我們將它存為一個(gè)integer
glBufferSubData(GL_UNIFORM_BUFFER, 144, 4, &b); 
glBindBuffer(GL_UNIFORM_BUFFER, 0);

同樣的步驟也能應(yīng)用到Uniform塊中其它的uniform變量上光涂，但需要使用不同的范圍參數(shù)。

一個(gè)簡(jiǎn)單的例子

所以拧烦，我們來展示一個(gè)真正使用Uniform緩沖對(duì)象的例子忘闻。如果我們回頭看看之前所有的代碼例子，我們不斷地在使用3個(gè)矩陣：投影恋博、觀察和模型矩陣齐佳。在所有的這些矩陣中，只有模型矩陣會(huì)頻繁變動(dòng)债沮。如果我們有多個(gè)著色器使用了這同一組矩陣炼吴，那么使用Uniform緩沖對(duì)象可能會(huì)更好。

我們會(huì)將投影和模型矩陣存儲(chǔ)到一個(gè)叫做Matrices的Uniform塊中疫衩。我們不會(huì)將模型矩陣存在這里硅蹦，因?yàn)槟Ｐ途仃囋诓煌闹髦袝?huì)不斷改變，所以使用Uniform緩沖對(duì)象并不會(huì)帶來什么好處闷煤。

#version 330 core
layout (location = 0) in vec3 aPos;

layout (std140) uniform Matrices
{
    mat4 projection;
    mat4 view;
};
uniform mat4 model;

void main()
{
    gl_Position = projection * view * model * vec4(aPos, 1.0);
}

這里沒什么特別的童芹，除了我們現(xiàn)在使用的是一個(gè)std140布局的Uniform塊。我們將在例子程序中鲤拿，顯示4個(gè)立方體辐脖，每個(gè)立方體都是使用不同的著色器程序渲染的。這4個(gè)著色器程序?qū)⑹褂孟嗤捻旤c(diǎn)著色器皆愉，但使用的是不同的片段著色器嗜价，每個(gè)著色器會(huì)輸出不同的顏色。

首先幕庐，我們將頂點(diǎn)著色器的Uniform塊設(shè)置為綁定點(diǎn)0久锥。注意我們需要對(duì)每個(gè)著色器都設(shè)置一遍。

unsigned int uniformBlockIndexRed    = glGetUniformBlockIndex(shaderRed.ID, "Matrices");
unsigned int uniformBlockIndexGreen  = glGetUniformBlockIndex(shaderGreen.ID, "Matrices");
unsigned int uniformBlockIndexBlue   = glGetUniformBlockIndex(shaderBlue.ID, "Matrices");
unsigned int uniformBlockIndexYellow = glGetUniformBlockIndex(shaderYellow.ID, "Matrices");  

glUniformBlockBinding(shaderRed.ID,    uniformBlockIndexRed, 0);
glUniformBlockBinding(shaderGreen.ID,  uniformBlockIndexGreen, 0);
glUniformBlockBinding(shaderBlue.ID,   uniformBlockIndexBlue, 0);
glUniformBlockBinding(shaderYellow.ID, uniformBlockIndexYellow, 0);

接下來异剥，我們創(chuàng)建Uniform緩沖對(duì)象本身瑟由，并將其綁定到綁定點(diǎn)0：

unsigned int uboMatrices
glGenBuffers(1, &uboMatrices);

glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
glBufferData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), NULL, GL_STATIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);

glBindBufferRange(GL_UNIFORM_BUFFER, 0, uboMatrices, 0, 2 * sizeof(glm::mat4));

首先我們?yōu)榫彌_分配了足夠的內(nèi)存，它等于glm::mat4大小的兩倍冤寿。GLM矩陣類型的大小直接對(duì)應(yīng)于GLSL中的mat4歹苦。接下來青伤，我們將緩沖中的特定范圍（在這里是整個(gè)緩沖）鏈接到綁定點(diǎn)0。

剩余的就是填充這個(gè)緩沖了殴瘦。如果我們將投影矩陣的視野(Field of View)值保持不變（所以攝像機(jī)就沒有縮放了）狠角，我們只需要將其在程序中定義一次——這也意味著我們只需要將它插入到緩沖中一次。因?yàn)槲覀円呀?jīng)為緩沖對(duì)象分配了足夠的內(nèi)存蚪腋，我們可以使用glBufferSubData在進(jìn)入渲染循環(huán)之前存儲(chǔ)投影矩陣：

glm::mat4 projection = glm::perspective(glm::radians(45.0f), (float)width/(float)height, 0.1f, 100.0f);
glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(projection));
glBindBuffer(GL_UNIFORM_BUFFER, 0);

這里我們將投影矩陣儲(chǔ)存在Uniform緩沖的前半部分丰歌。在每次渲染迭代中繪制物體之前，我們會(huì)將觀察矩陣更新到緩沖的后半部分：

glm::mat4 view = camera.GetViewMatrix();           
glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));
glBindBuffer(GL_UNIFORM_BUFFER, 0);

Uniform緩沖對(duì)象的部分就結(jié)束了。每個(gè)包含了Matrices這個(gè)Uniform塊的頂點(diǎn)著色器將會(huì)包含儲(chǔ)存在uboMatrices中的數(shù)據(jù)。所以逸爵，如果我們現(xiàn)在要用4個(gè)不同的著色器繪制4個(gè)立方體，它們的投影和觀察矩陣都會(huì)是一樣的晓勇。

glBindVertexArray(cubeVAO);
shaderRed.use();
glm::mat4 model;
model = glm::translate(model, glm::vec3(-0.75f, 0.75f, 0.0f));  // 移動(dòng)到左上角
shaderRed.setMat4("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);        
// ... 繪制綠色立方體
// ... 繪制藍(lán)色立方體
// ... 繪制黃色立方體 

唯一需要設(shè)置的uniform只剩model uniform了。在像這樣的場(chǎng)景中使用Uniform緩沖對(duì)象會(huì)讓我們?cè)诿總€(gè)著色器中都剩下一些uniform調(diào)用灌旧。最終的結(jié)果會(huì)是這樣的：

因?yàn)樾薷牧四Ｐ途仃囅叮總€(gè)立方體都移動(dòng)到了窗口的一邊，并且由于使用了不同的片段著色器节榜，它們的顏色也不同羡玛。這只是一個(gè)很簡(jiǎn)單的情景，我們可能會(huì)需要使用Uniform緩沖對(duì)象宗苍，但任何大型的渲染程序都可能同時(shí)激活有上百個(gè)著色器程序稼稿，這時(shí)候Uniform緩沖對(duì)象的優(yōu)勢(shì)就會(huì)很大地體現(xiàn)出來了。

你可以在這里找到uniform例子程序的完整源代碼讳窟。

#include <glad/glad.h>  
#include <GLFW/glfw3.h>  
#include <stb_image.h>  
#include <glm/glm.hpp>  
#include <glm/gtc/matrix_transform.hpp>  
#include <glm/gtc/type_ptr.hpp>  
#include <learnopengl/shader_m.h>  
#include <learnopengl/camera.h>  
#include <learnopengl/model.h>  
#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void mouse_callback(GLFWwindow* window, double xpos, double ypos);
void processInput(GLFWwindow *window);

// settings
const unsigned int SCR_WIDTH = 1280;
const unsigned int SCR_HEIGHT = 720;

// camera
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
float lastX = (float)SCR_WIDTH / 2.0;
float lastY = (float)SCR_HEIGHT / 2.0;
bool firstMouse = true;

// timing
float deltaTime = 0.0f;
float lastFrame = 0.0f;

int main()
{
    // glfw: initialize and configure
    // ------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
#endif

    // glfw window creation
    // --------------------
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
    if (window == NULL)
    {
        std::cout << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetCursorPosCallback(window, mouse_callback);

    // tell GLFW to capture our mouse
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

    // glad: load all OpenGL function pointers
    // ---------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // configure global opengl state
    // -----------------------------
    glEnable(GL_DEPTH_TEST);

    // build and compile shaders
    // -------------------------
Shader shaderRed("8.advanced_glsl.vs", "8.red.fs"); 
Shader shaderGreen("8.advanced_glsl.vs", "8.green.fs"); 
Shader shaderBlue("8.advanced_glsl.vs", "8.blue.fs"); 
Shader shaderYellow("8.advanced_glsl.vs", "8.yellow.fs");
// set up vertex data (and buffer(s)) and configure vertex attributes
    // ------------------------------------------------------------------
    float cubeVertices[] = {
        // positions         
        -0.5f, -0.5f, -0.5f, 
         0.5f, -0.5f, -0.5f,  
         0.5f,  0.5f, -0.5f,  
         0.5f,  0.5f, -0.5f,  
        -0.5f,  0.5f, -0.5f, 
        -0.5f, -0.5f, -0.5f, 

        -0.5f, -0.5f,  0.5f, 
         0.5f, -0.5f,  0.5f,  
         0.5f,  0.5f,  0.5f,  
         0.5f,  0.5f,  0.5f,  
        -0.5f,  0.5f,  0.5f, 
        -0.5f, -0.5f,  0.5f, 

        -0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f, -0.5f, 
        -0.5f, -0.5f, -0.5f, 
        -0.5f, -0.5f, -0.5f, 
        -0.5f, -0.5f,  0.5f, 
        -0.5f,  0.5f,  0.5f, 

         0.5f,  0.5f,  0.5f,  
         0.5f,  0.5f, -0.5f,  
         0.5f, -0.5f, -0.5f,  
         0.5f, -0.5f, -0.5f,  
         0.5f, -0.5f,  0.5f,  
         0.5f,  0.5f,  0.5f,  

        -0.5f, -0.5f, -0.5f, 
         0.5f, -0.5f, -0.5f,  
         0.5f, -0.5f,  0.5f,  
         0.5f, -0.5f,  0.5f,  
        -0.5f, -0.5f,  0.5f, 
        -0.5f, -0.5f, -0.5f, 

        -0.5f,  0.5f, -0.5f, 
         0.5f,  0.5f, -0.5f,  
         0.5f,  0.5f,  0.5f,  
         0.5f,  0.5f,  0.5f,  
        -0.5f,  0.5f,  0.5f, 
        -0.5f,  0.5f, -0.5f, 
    };
    // cube VAO
    unsigned int cubeVAO, cubeVBO;
    glGenVertexArrays(1, &cubeVAO);
    glGenBuffers(1, &cubeVBO);
    glBindVertexArray(cubeVAO);
    glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(cubeVertices), &cubeVertices, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

    // configure a uniform buffer object
    // ---------------------------------
    // first. We get the relevant block indices
    unsigned int uniformBlockIndexRed = glGetUniformBlockIndex(shaderRed.ID, "Matrices");
    unsigned int uniformBlockIndexGreen = glGetUniformBlockIndex(shaderGreen.ID, "Matrices");
    unsigned int uniformBlockIndexBlue = glGetUniformBlockIndex(shaderBlue.ID, "Matrices");
    unsigned int uniformBlockIndexYellow = glGetUniformBlockIndex(shaderYellow.ID, "Matrices");
    // then we link each shader's uniform block to this uniform binding point
    glUniformBlockBinding(shaderRed.ID, uniformBlockIndexRed, 0);
    glUniformBlockBinding(shaderGreen.ID, uniformBlockIndexGreen, 0);
    glUniformBlockBinding(shaderBlue.ID, uniformBlockIndexBlue, 0);
    glUniformBlockBinding(shaderYellow.ID, uniformBlockIndexYellow, 0);
    // Now actually create the buffer
    unsigned int uboMatrices;
    glGenBuffers(1, &uboMatrices);
    glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
    glBufferData(GL_UNIFORM_BUFFER, 2 * sizeof(glm::mat4), NULL, GL_STATIC_DRAW);
    glBindBuffer(GL_UNIFORM_BUFFER, 0);
    // define the range of the buffer that links to a uniform binding point
    glBindBufferRange(GL_UNIFORM_BUFFER, 0, uboMatrices, 0, 2 * sizeof(glm::mat4));

    // store the projection matrix (we only do this once now) (note: we're not using zoom anymore by changing the FoV)
    glm::mat4 projection = glm::perspective(45.0f, (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
    glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(projection));
    glBindBuffer(GL_UNIFORM_BUFFER, 0);
  
    // render loop
    // -----------
    while (!glfwWindowShouldClose(window))
    {
        // per-frame time logic
        // --------------------
        float currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        // input
        // -----
        processInput(window);

        // render
        // ------
        glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // set the view and projection matrix in the uniform block - we only have to do this once per loop iteration.
        glm::mat4 view = camera.GetViewMatrix();
        glBindBuffer(GL_UNIFORM_BUFFER, uboMatrices);
        glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(view));
        glBindBuffer(GL_UNIFORM_BUFFER, 0);

        // draw 4 cubes 
        // RED
        glBindVertexArray(cubeVAO);
        shaderRed.use();
        glm::mat4 model;
        model = glm::translate(model, glm::vec3(-0.75f, 0.75f, 0.0f)); // move top-left
        shaderRed.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        // GREEN
        shaderGreen.use();
        model = glm::mat4();
        model = glm::translate(model, glm::vec3(0.75f, 0.75f, 0.0f)); // move top-right
        shaderGreen.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        // YELLOW
        shaderYellow.use();
        model = glm::mat4();
        model = glm::translate(model, glm::vec3(-0.75f, -0.75f, 0.0f)); // move bottom-left
        shaderYellow.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);
        // BLUE
        shaderBlue.use();
        model = glm::mat4();
        model = glm::translate(model, glm::vec3(0.75f, -0.75f, 0.0f)); // move bottom-right
        shaderBlue.setMat4("model", model);
        glDrawArrays(GL_TRIANGLES, 0, 36);

        // glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
        // -------------------------------------------------------------------------------
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // optional: de-allocate all resources once they've outlived their purpose:
    // ------------------------------------------------------------------------
    glDeleteVertexArrays(1, &cubeVAO);
    glDeleteBuffers(1, &cubeVBO);

    glfwTerminate();
    return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
    if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
        glfwSetWindowShouldClose(window, true);

    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        camera.ProcessKeyboard(FORWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        camera.ProcessKeyboard(BACKWARD, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        camera.ProcessKeyboard(LEFT, deltaTime);
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        camera.ProcessKeyboard(RIGHT, deltaTime);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
    // make sure the viewport matches the new window dimensions; note that width and 
    // height will be significantly larger than specified on retina displays.
    glViewport(0, 0, width, height);
}

// glfw: whenever the mouse moves, this callback is called
// -------------------------------------------------------
void mouse_callback(GLFWwindow* window, double xpos, double ypos)
{
    if (firstMouse)
    {
        lastX = xpos;
        lastY = ypos;
        firstMouse = false;
    }

    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top

    lastX = xpos;
    lastY = ypos;

    camera.ProcessMouseMovement(xoffset, yoffset);
}

Uniform緩沖對(duì)象比起獨(dú)立的uniform有很多好處让歼。第一，一次設(shè)置很多uniform會(huì)比一個(gè)一個(gè)設(shè)置多個(gè)uniform要快很多丽啡。第二谋右，比起在多個(gè)著色器中修改同樣的uniform，在Uniform緩沖中修改一次會(huì)更容易一些补箍。最后一個(gè)好處可能不會(huì)立即顯現(xiàn)改执，如果使用Uniform緩沖對(duì)象的話，你可以在著色器中使用更多的uniform坑雅。OpenGL限制了它能夠處理的uniform數(shù)量辈挂，這可以通過GL_MAX_VERTEX_UNIFORM_COMPONENTS來查詢。當(dāng)使用Uniform緩沖對(duì)象時(shí)裹粤，最大的數(shù)量會(huì)更高终蒂。所以，當(dāng)你達(dá)到了uniform的最大數(shù)量時(shí)（比如再做骨骼動(dòng)畫(Skeletal Animation)的時(shí)候），你總是可以選擇使用Uniform緩沖對(duì)象拇泣。

后記

未完噪叙，待續(xù)~~~