一、在GLSL中使用Uniform Block

在GLSL渲染語言中，我們經常採用緩衝區來儲存Uniform型的Block。

比如我們需要繪製下面這樣的效果：

在這裡我們繪製了一個圓，圓內部顏色和外部顏色不同，而且邊緣部分，顏色是平滑過渡的。

我們這樣來實現這一效果：

首先定義一個內徑和外徑。然後給這個正方形分配紋理座標，然後通過紋理座標離(0.5,0.5)的距離與內徑和外徑的關係來控制當前畫素點的顏色。

我們要在Shader中提供這樣的一些資訊：圓的內徑及外徑、內部顏色和外部顏色。採用Block來將這些資訊封裝在一起是合適的選擇。

採用Block的原因是：

如果你的程式中包含了多個著色器，而且這些著色器使用了相同的Uniform變數，你就不得不為每個著色器分別管理這些變數。Uniform變數的location是在程式連結的時候產生的，因此Uniform變數的location會隨著著色器的不同而發生變化。因此，這些Uniform變數的資料必須重新產生，然後應用到新的location上。

而Uniform Block正是為了使在著色器間共享Uniform資料變得更加容易而設計的。有了Uniform Block，我們可以建立一個緩衝區物件來儲存這些Uniform變數的值，然後將緩衝區物件繫結到Uniform Block。當著色器程式改變的時候，只需要將同樣的緩衝區對重新繫結到在新的著色器中與之相關的Block即可。

Uniform Block的定義和C/C++中的struct很類似。在本文的例子中我們需要定義的Uniform Block為：

方法一：

1. uniform BlobSettings {  
2.   vec4 InnerColor;  
3.   vec4 OuterColor;  
4. float RadiusInner;  
5. float RadiusOuter;  
6. };  

uniform BlobSettings {
  vec4 InnerColor;
  vec4 OuterColor;
  float RadiusInner;
  float RadiusOuter;
};

或者是

方法二：

1. uniform BlobSettings{  
2.     vec4 InnerColor;  
3.     vec4 OuterColor;  
4. float RadiusInner;  
5. float RadiusOuter;  
6. }Blob;  

uniform BlobSettings{
	vec4 InnerColor;
	vec4 OuterColor;
	float RadiusInner;
	float RadiusOuter;
}Blob;

這樣我們就定義了一個名為BlobSettings的Block，包含了4個uniform 變數。
在方法一中，Block中的變數依然是全域性域的一部分，取用的時候不用Block名。

而在方法二中，Block中的變數則是在Blob名字域中，取用的時候需要加上Block名。

這兩種方法在使用上有少許差別。

用來儲存uniform資料的緩衝區物件稱作UBO（uniform buffer object）。它只是一個繫結到特定location的緩衝區物件。

注意下面的程式碼是基於上述定義Block的方法二的基礎之上的。

下面貼出完整的GLSL渲染器程式碼：

basic_block.vert:

1. #version 400
2. layout (location = 0) in vec3 VertexPosition;  
3. layout (location = 1) in vec3 VertexTexCoord;  
4. out vec3 TexCoord;  
5. void main()  
6. {  
7.     TexCoord = VertexTexCoord;  
8.     gl_Position = vec4(VertexPosition,1.0);  
9. }  

#version 400

layout (location = 0) in vec3 VertexPosition;
layout (location = 1) in vec3 VertexTexCoord;

out vec3 TexCoord;

void main()
{
	TexCoord = VertexTexCoord;
	gl_Position = vec4(VertexPosition,1.0);
}

basic_block.frag:

1. #version 400
2. in vec3 TexCoord;  
3. layout (location = 0) out vec4 FragColor;  
4. uniform BlobSettings{  
5.     vec4 InnerColor;  
6.     vec4 OuterColor;  
7. float RadiusInner;  
8. float RadiusOuter;  
9. }Blob;//Use an instance name with a uniform block
10. void main()  
11. {  
12. float dx = TexCoord.x - 0.5;  
13. float dy = TexCoord.y - 0.5;  
14. float dist = sqrt(dx * dx + dy * dy);  
15. //smoothstep : perform Hermite interpolation between two values
16.     FragColor = mix(Blob.InnerColor,Blob.OuterColor,  
17.             smoothstep(Blob.RadiusInner,Blob.RadiusOuter,dist));  
18. }  

#version 400

in vec3 TexCoord;
layout (location = 0) out vec4 FragColor;

uniform BlobSettings{
	vec4 InnerColor;
	vec4 OuterColor;
	float RadiusInner;
	float RadiusOuter;
}Blob;//Use an instance name with a uniform block

void main()
{
	float dx = TexCoord.x - 0.5;
	float dy = TexCoord.y - 0.5;
	float dist = sqrt(dx * dx + dy * dy);
	//smoothstep : perform Hermite interpolation between two values
	FragColor = mix(Blob.InnerColor,Blob.OuterColor,
			smoothstep(Blob.RadiusInner,Blob.RadiusOuter,dist));
}

UBO的設定：

1. void Scenebasic_block::setUniformBlock()  
2. {  
3.     GLuint blockIndex = glGetUniformBlockIndex(prog.getHandle(),  
4. "BlobSettings");  
5.     GLint blockSize;  
6.     glGetActiveUniformBlockiv(prog.getHandle(),  
7.                             blockIndex,  
8.                             GL_UNIFORM_BLOCK_DATA_SIZE,  
9.                             &blockSize);  
10.     GLubyte *blockBuffer = (GLubyte*)malloc(blockSize);  
11. //Query for the offsets of the each block variable
12. //layout of the data within a uniform block is implementation dependent
13. const GLchar *names[] = {"BlobSettings.InnerColor","BlobSettings.OuterColor",  
14. "BlobSettings.RadiusInner","BlobSettings.RadiusOuter"};  
15.     GLuint indices[4];  
16.     glGetUniformIndices(prog.getHandle(), 4, names, indices);  
17.     GLint offset[4];  
18.     glGetActiveUniformsiv(prog.getHandle(), 4, indices, GL_UNIFORM_OFFSET, offset);  
19.     GLfloat outerColor[] = {0.0f, 0.0f, 0.0f, 0.0f};  
20.     GLfloat innerColor[] = {1.0f, 1.0f, 0.75f, 1.0f};  
21.     GLfloat innerRadius = 0.25f, outerRadius = 0.45f;  
22.     memcpy(blockBuffer + offset[0],innerColor,4 * sizeof(float));  
23.     memcpy(blockBuffer + offset[1],outerColor,4 * sizeof(float));  
24.     memcpy(blockBuffer + offset[2],&innerRadius,sizeof(float));  
25.     memcpy(blockBuffer + offset[3],&outerRadius,sizeof(float));  
26. //create OpenGL buffer UBO to store the data
27.     GLuint uboHandle;  
28.     glGenBuffers(1,&uboHandle);  
29.     glBindBuffer(GL_UNIFORM_BUFFER,uboHandle);  
30.     glBufferData(GL_UNIFORM_BUFFER,blockSize,blockBuffer,  
31.                     GL_DYNAMIC_DRAW);  
32. //bind the UBO th the uniform block
33.     glBindBufferBase(GL_UNIFORM_BUFFER,blockIndex,uboHandle);  
34.     free(blockBuffer);  
35. }  

void Scenebasic_block::setUniformBlock()
{
	GLuint blockIndex = glGetUniformBlockIndex(prog.getHandle(),
												"BlobSettings");
	GLint blockSize;
	glGetActiveUniformBlockiv(prog.getHandle(),
							blockIndex,
							GL_UNIFORM_BLOCK_DATA_SIZE,
							&blockSize);
	GLubyte *blockBuffer = (GLubyte*)malloc(blockSize);
	//Query for the offsets of the each block variable
	//layout of the data within a uniform block is implementation dependent
	const GLchar *names[] = {"BlobSettings.InnerColor","BlobSettings.OuterColor",
							"BlobSettings.RadiusInner","BlobSettings.RadiusOuter"};
	GLuint indices[4];
	glGetUniformIndices(prog.getHandle(), 4, names, indices);

	GLint offset[4];
	glGetActiveUniformsiv(prog.getHandle(), 4, indices, GL_UNIFORM_OFFSET, offset);

	GLfloat outerColor[] = {0.0f, 0.0f, 0.0f, 0.0f};
	GLfloat innerColor[] = {1.0f, 1.0f, 0.75f, 1.0f};
	GLfloat innerRadius = 0.25f, outerRadius = 0.45f;

	memcpy(blockBuffer + offset[0],innerColor,4 * sizeof(float));
	memcpy(blockBuffer + offset[1],outerColor,4 * sizeof(float));
	memcpy(blockBuffer + offset[2],&innerRadius,sizeof(float));
	memcpy(blockBuffer + offset[3],&outerRadius,sizeof(float));

	//create OpenGL buffer UBO to store the data
	GLuint uboHandle;
	glGenBuffers(1,&uboHandle);
	glBindBuffer(GL_UNIFORM_BUFFER,uboHandle);
	glBufferData(GL_UNIFORM_BUFFER,blockSize,blockBuffer,
					GL_DYNAMIC_DRAW);

	//bind the UBO th the uniform block
	glBindBufferBase(GL_UNIFORM_BUFFER,blockIndex,uboHandle);

	free(blockBuffer);
}

二、在Uniform Block中使用佈局識別符號std140

1、std140的使用
由於UBO中資料的佈局和具體實現有關（記憶體對齊等等），因此我們需要在設定其值的時候查詢偏移量。然後，我們可以使用標準佈局std40來避免這一操作。這可以通過在定義Uniform Block的時候使用佈局識別符號來實現：

layout( std140 ) uniform BlobSettings {
   …
};

2、std140詳解

std40佈局識別符號要求GLSL著色器依據一組規則來組織Uniform Block中的變數，這樣使得我們能夠預先計算出其中的變數的偏移量。

變數的偏移量是根據起始偏移量和在其之前的變數的大小累積計算得到的。第一個成員變數的起始偏移量總是0.

std40的佈局規則