OpenGL学习笔记 transform feedback缓存&粒子系统示例分析

心已赠人 2022-08-20 04:13 461阅读 0赞

http://blog.csdn.net/coderling/article/details/44742077

transform feedback是OpenGL中比较酷炫的特性之一，他让客户端应用程序可以获取到渲染流水线上的顶点数据。基于这一特性实现了基于z-pass场景决策渲染技术，当然在此并没有去了解何为z-pass场景决策渲染技术，总之是一个可以有效减少渲染数据的输送。这里只是通过一个简单的例子系统，去了解transform feedback对象的使用方法。

##  正文： ##

###  1、transform feedback: ###

transform feedback是OpenGL渲染管线中，顶点处理阶段结束之后，图元装配和光栅化之前的一个步骤。transform feedback可以重新捕获即将装配为图元(点，线段，三角形)的顶点，然后你将他们的部分或者全部属性传递到缓存对象。每个顶点在传递到图元装配阶段时（之前），将所有需要捕获的属性数据记录到一个或者多个缓存对象当中（至于捕获那些数据，都是在我们控制之下的），程序可以通过缓存回读这些数据，或者将他们用于后续的渲染操作。

tansform feedback所有状态通过一个transform feedback对象管理，这个状态包括所有用于记录顶点数据的缓存对象，用于标识缓存对象的计数器（名称glGen\*系列函数返回），以及用于标识transform feedback当前是否启用的状态量。transform对象的创建绑定过程和一般的OpenGL对象相似：

a. void glGenTransformFeedbacks( GLsizei n, GLuint\* ids ) 为transform feedback对象生成n个名称，并且将生成的名称记录到数组ids中。0是保留名称，openGL默认tranform feedback，函数将永远不会返回0.

b. void glBindTransformFeedback( GLenum target, GLuint id ) 将一个id(glGen\*返回的名称)绑定到指定的target(必须是GL\_TRANSFORM\_FEEDBACK)所指定的环境中。他做了三个工作：1、如果第一次绑定这个名称，将创建一个tranform feedback对象，使用默认状态值对他进行初始化，并设为当前transform feedback;2、否则单纯的帮该transform feedback激活为当前；3、如果id为0，则相当于重新回到默认的transform feedback对象上（解除所有值钱绑定的transform feedback对象）

c. GLboolean glIsTransformFeedback( GLenum id )判断id是否为一个transform feedback对象。

d.当绑定了一个transform feedback对象之后，所有可能会影响到transform feedback状态的命令都会作用于这个对象。不过并不需要为了使用transform feedback相关功能而去特别定义一个transform feedback对象想，因为系统会内置一个默认的transform feedback对象（名称为id = 0）

e. void glDeleteTransformFeedbacks( GLsizei n, const GLuint\* ids )删除n个transform feedback对象。在本次transform feedback结束之后才回去删除

###  2.transform feedback缓存 ###

transform feedback主要用来管理将顶点捕捉到缓存对象的相关状态。这个状态中包含当前连接到的transform feedback缓存绑定点的缓存对象。可以同时给transform feedback绑定多个缓存，也可以绑定缓存对象的多个子块，甚至可以将同一个缓存对象不用子块绑定到不同的transform feedback缓存绑定点上。

绑定接口： void glBindBufferBase( GLenum target, GLuint index, GLuint buffer ) 其中target自然必须为GL\_TRANSFORM\_FEEDBACK\_BUFFER，而index必须为当前绑定的transform feedback对象的缓存绑定点索引，绑定点最大数与设备实现有关可以通关GL\_MAX\_TRANSFORM\_FEEDBACK\_BUFFERS的值来查询。所有的OpenGL设备实现都可以至少支持64个绑定点。也可以将一个缓存对象的一部分绑定到某个transform feedback绑定点：void glBindBufferRange( GLenum GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) offset 和size单位都为字节，定义了buffer缓存的范围。需要特别注意的是亮点：1、保证一个缓存绑定到多个transform feedback绑定点时他们使用的区域不能重叠。2.、glBindBufferBase()和glBindBufferRange()都不会主动去创建缓存对象（这与glBindBuffer不同），而创建缓存对象的工作还是由glBindBuffer()来承担，数据操作还是由glBufferData(),glBufferSubData(),glGetBufferSubData()来完成。

（关于缓存绑定点的解释：在这里可能会问缓存绑定点指的是什么？其实就是一个点，也可以理解为一个名称，他有着最大限制，至少为64，是着色器访问缓存对象的一个桥梁（快速便捷的），略微搜了下，有个一个叫UBO（uniform Block Object）的应用，看了多少会对绑定点有所了解，遗憾的是并没有找到，transform feedback的关于这个桥梁保证准确找到数据的呢？现在也并不能很好的理解之，mark下一个地址： [http://www.zwqxin.com/archives/opengl/talk-about-transform-feedback.html][http_www.zwqxin.com_archives_opengl_talk-about-transform-feedback.html] 讲述了transform feedback的高级应用 ）

初始化过程示例：

//缓存名称

GLuint buffer;

glGenBuffers( 1, &buffer )

//绑定到TRANSFORM\_FEEDBACK创建缓存对象。

glBindBuffer( GL\_TRANSFORM\_FEEDBACK\_BUFFER, buffer )

//glBufferData初始化数据，参数为NULL,申请空间保留使用

glBufferData( GL\_TRANFORM\_FEEDBACK\_BUFFER, 1024\*1024, NULL, GL\_DYNAMIC\_COPY )

//绑定到缓存绑定点,一般用于index = 1，一般用于index = 0

glBindBufferRange( GL\_TRANSFORM\_FEEDBACK\_BUFFER, 0, buffer, 0, 512\*1024 )

glBindBufferRange( GL\_TRANSFORM\_FEEDBACK\_BUFFER, 1, buffer, 512\*1024, 512\*1024 )

###  3、transform feedback的变量配置 ###

transform feedback所绑定的缓存是一个transform feedback对象关联在一起，顶点（或者几何）着色器的输出要记录在那些缓存当中，这些配置信息是保存在当前程序对象当中。openGL提供了相应的接口让我们配置那些变量应该被记录。

void glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar\*\* varyings, GLenum bufferMode )

参数varyings指定了一个变量数组，也就是那些需要被feedback的变量。program是对应的着色器程序，count表示varyings中字符串的数量，bufferMode指定了捕获变量的模式：a、分离模式（GL\_SEPARATE\_ATTRIBS）：每个变量将会被记录到单独的缓存对象中；b、交叉模式（GL\_INTERLEAVED\_ATTRIBS）: 那么所有的变量是一个接着一个记录到绑定到当前transform feedback对象的第一个绑定点的缓存对象里！

openGL还提供了一些内置变量来帮助 我们更灵活的控制捕获的数据在缓存中的对齐方式：gl\_SkipComponents1、gl\_SkipComponents2、gl\_SkipComponents3、gl\_SkipComponents4、gl\_NextBuffer。对于gl\_SkipComponents\*，OpenGL会留出指定数量的空隙（1，2，3，4）。当捕获模式为交叉模式这些才可以使用这些gl\_SkipComponents\*内置变量；而对于gl\_NextBuffer，OpenGL会把变量传递到当前绑定点的下一个transform feedback缓存中，这样在GL\_INTERLEAVED\_ATTRIBS模式下也可以将变量保存在单独的缓存当中，如果捕获模式为GL\_SEPARATE\_ATTRIBS是遇到gl\_NextBuffer，或者在GL\_INTERLEAVED\_ATTRIBS下连续遇到gl\_NextBuffer（两个而上）那么将跳过当前绑定点，并在当前绑定的缓存中不会记录任何数据。 在这里似乎可以回答之前括号里面关于绑定点的疑惑：首先每个绑定点对应于一个缓存或一部分缓存，他总是独立享有指定的缓存，不能与其他绑定点交叉。对于顶点着色器和几何着色器而言绑定点似乎可以理解为地址。在捕获数据是总是先从索引为当前transform feedback对象的第一个绑定点索引开始（索引值最小那个）输出数据，并根据glTransformFeedbackVaryings() varyings 参数指定的对齐方式存放在缓存当中。

### 4、transform feedback捕获启动与停止、 ###

transform feedback 可以随时启动和停止，甚至暂停。一些控制transform启动停止的api:

void glBeginTransformFeedback( GLenum primitiveMode )：开始并设置transform feedback将要记录的图元类型，primitiveMode必须是：GL\_POINTS, GL\_LINES、GL\_TRIANGLES三个之一。在之后的绘制命令中团员类型需要与之相符，或则几何着色器中输出类型需要与之相符。、

void glPuaseTransformFeedback():暂停transform feedback对变量的记录，但transform feedback还是处于启动状态。如果transform feedback没有启动则OpenGL产生错误。

void glResumeTransformFeedback():重新开启一个之前通过glPuaseTransformFeedback()暂停的feedback过程，如果transform feedback没有启动，或者没有被处于活动状态，则产生OpenGL错误。

void glEndTransformFeedback()结束transform feedback过程。

### 5、基于transform feedback的粒子系统分析 ###

程序分为两个处理过程，创建了2个着色器分别管理这两个过程。第一个负责渲染模型对象，第二个负责渲染粒子和实现粒子与模型对象的碰撞检测。在碰撞检测过程中用到的模型顶点数据就是将是通过transform feedback获取，而由于需要记录粒子的位置速度信息需要保留给当前渲染使用，单一缓冲无法对新数据进行记录，所以采用了双缓冲区，同样使用transform feedback来记录本次粒子渲染结果，给下一帧使用。

粒子系统渲染顶点着色器分析：

\#version 410

uniform mat4 model\_matrix;

uniform mat4 projection\_matrix;

uniform int triangle\_count;//模型的，在绘制更新粒子前赋值三角形数量

//输入

layout (location = 0) in vec4 position;

layout (location = 1) in vec3 velocity;

//输出

out vec4 position\_out;

out vec3 velocity\_out;

//在transform feedback记录的数据，使用纹理查找tbo获取三角形平面

uniform samplerBuffer geometry\_tbo;

uniform float time\_step = 0.02;//更新时间步长

//线段与三角形平面相交测试

bool intersect(vec3 origin, vec3 direction, vec3 v0, vec3 v1, vec3 v2, out vec3 point)

vec3 u, v, n;

vec3 w0, w;

float r, a, b;

u = (v1 - v0);

v = (v2 - v0);

n = cross(u, v);

if (length(n) < 0.1)

return false;

w0 = origin - v0;

a = -dot(n, w0);

b = dot(n, direction);

if (abs(b) < 0.1)

return false;

r = a / b;

if (r < 0.0 || r > 1.0)

return false;

point = origin + r \* direction;

float uu, uv, vv, wu, wv, D;

uu = dot(u, u);

uv = dot(u, v);

vv = dot(v, v);

w = point - v0;

wu = dot(w, u);

wv = dot(w, v);

D = uv \* uv - uu \* vv;

float s, t;

s = (uv \* wv - vv \* wu) / D;

if (s < 0.0 || s > 1.0)

return false;

t = (uv \* wu - uu \* wv) / D;

if (t < 0.0 || (s + t) > 1.0)

return false;

return true;

//碰撞后反射向量计算

vec3 reflect\_vector(vec3 v, vec3 n)

return v - 2.0 \* dot(v, n) \* n;

void main(void)

vec3 accelleration = vec3(0.0, -0.3, 0.0);

vec3 new\_velocity = velocity + accelleration \* time\_step;

vec4 new\_position = position + vec4(new\_velocity \* time\_step, 0.0);//计算粒子新的速度和位置

vec3 v0, v1, v2;

vec3 point;

int i;

for (i = 0; i < triangle\_count; i++)

//利用纹理查找tbo获取模型的三角形平面。做相交测试，如果相交在交点处计算反弹之后的新速度向量和位置

v0 = texelFetch(geometry\_tbo, i \* 3).xyz

v1 = texelFetch(geometry\_tbo, i \* 3 + 1).xyz;

v2 = texelFetch(geometry\_tbo, i \* 3 + 2).xyz;

if (intersect(position.xyz, position.xyz - new\_position.xyz, v0, v1, v2, point))

vec3 n = normalize(cross(v1 - v0, v2 - v0));

new\_position = vec4(point + reflect\_vector(new\_position.xyz - point, n), 1.0);

new\_velocity = 0.8 \* reflect\_vector(new\_velocity, n);

//超出一定范围，回归。

if (new\_position.y < -80.0)

new\_position = vec4(-new\_position.x \* 0.3, position.y + 200.0, 0.0, 1.0);

new\_velocity \*= vec3(0.2, 0.1, -0.3);

velocity\_out = new\_velocity \* 0.9999;//几乎无衰减的速度

position\_out = new\_position;

gl\_Position = projection\_matrix \* (model\_matrix \* position);

粒子系统片元着色器：非常简单，只是设置了粒子的颜色为白色。

\#version 410

layout (location = 0) out vec4 color;\\

void main(void)

color = vec4(1.0);

模型渲染的顶点着色器和片元着色器和之前的例子没什么区别。可以再代码里面看到。或者在之前的文章中看到相关详细注释

### 5.粒子实例运行截图 ###

![Center][]

粒子从模型头顶落下

![Center 1][]

![Center 2][]

粒子撞击模型时被弹开

![Center 3][]

Then End~~~

（牢骚：愈发无聊的生活，愈发没有激情的工作，青春只是在流逝，没有痕迹）

### 被遗忘的代码（15.3.31） ###

**\[cpp\]** [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include "transform\_fb.h"
2.  \#include "vbm\_xfb.h"
3.  \#include "vutils.h"
4.  \#include "vmath.h"
5.  
6.  **namespace** transform 
7.  \{ 
8.  **float** aspect = 800.0/600.0; 
9.   GLuint update\_prog; 
10.  GLuint vao\[2\]; 
11.  GLuint vbo\[2\]; 
12.  GLuint xfb; 
13. 
14.  GLuint render\_prog; 
15.  GLuint geometry\_vbo; 
16.  GLuint render\_vao; 
17.  GLint render\_model\_matrix\_loc; 
18.  GLint render\_projection\_matrix\_loc; 
19. 
20.  GLuint geometry\_tex; 
21. 
22.  GLuint geometry\_xfb; 
23.  GLuint particle\_xfb; 
24. 
25.  GLint model\_matrix\_loc; 
26.  GLint projection\_matrix\_loc; 
27.  GLint triangle\_count\_loc; 
28.  GLint time\_step\_loc; 
29. 
30.  VBObject object; 
31. 
32. **const****int** point\_count = 5000; 
33. **static** unsigned **int** seed = 0x13371337; 
34. \}; 
35. 
36. **using****namespace** transform; 
37. 
38. **static****inline****float** random\_float() 
39. \{ 
40. **float** res; 
41.  unsigned **int** tmp; 
42. 
43.  seed \*= 16807; 
44. 
45.  tmp = seed ^ (seed >> 4) ^ (seed << 15); 
46. 
47.  \*((unsigned **int** \*)&res) = (tmp >> 9) | 0x3F800000; 
48. 
49. **return** (res - 1.0f); 
50. \} 
51. 
52. **static** vmath::vec3 random\_vector(**float** minmag = 0.0f, **float** maxmag = 1.0f) 
53. \{ 
54.  vmath::vec3 randomvec(random\_float() \* 2.0f - 1.0f, random\_float() \* 2.0f - 1.0f, random\_float() \* 2.0f - 1.0f); 
55.  randomvec = normalize(randomvec); 
56.  randomvec \*= (random\_float() \* (maxmag - minmag) + minmag); 
57. 
58. **return** randomvec; 
59. \} 
60. 
61. **static****inline****int** min(**int** a, **int** b) 
62. \{ 
63. **return** a < b ? a : b; 
64. \} 
65. 
66. **void** transformFBInit() 
67. \{ 
68. **int** i, j; 
69.  update\_prog = glCreateProgram(); 
70. 
71. **static****const****char** update\_vs\_source\[\] = 
72. "\#version 410\\n"
73. "\\n"
74. "uniform mat4 model\_matrix;\\n"
75. "uniform mat4 projection\_matrix;\\n"
76. "uniform int triangle\_count;\\n"
77. "\\n"
78. "layout (location = 0) in vec4 position;\\n"
79. "layout (location = 1) in vec3 velocity;\\n"
80. "\\n"
81. "out vec4 position\_out;\\n"
82. "out vec3 velocity\_out;\\n"
83. "\\n"
84. "uniform samplerBuffer geometry\_tbo;\\n"
85. "uniform float time\_step = 0.02;\\n"
86. "\\n"
87. "bool intersect(vec3 origin, vec3 direction, vec3 v0, vec3 v1, vec3 v2, out vec3 point)\\n"
88. "\{\\n"
89. " vec3 u, v, n;\\n"
90. " vec3 w0, w;\\n"
91. " float r, a, b;\\n"
92. "\\n"
93. " u = (v1 - v0);\\n"
94. " v = (v2 - v0);\\n"
95. " n = cross(u, v);\\n"
96. // " if (length(n) < 0.1)\\n"
97. // " return false;\\n"
98. "\\n"
99. " w0 = origin - v0;\\n"
100. " a = -dot(n, w0);\\n"
101. " b = dot(n, direction);\\n"
102. //" if (abs(b) < 0.1)\\n"
103. //" return false;\\n"
104. "\\n"
105. " r = a / b;\\n"
106. " if (r < 0.0 || r > 1.0)\\n"
107. " return false;\\n"
108. "\\n"
109. " point = origin + r \* direction;\\n"
110. "\\n"
111. " float uu, uv, vv, wu, wv, D;\\n"
112. "\\n"
113. " uu = dot(u, u);\\n"
114. " uv = dot(u, v);\\n"
115. " vv = dot(v, v);\\n"
116. " w = point - v0;\\n"
117. " wu = dot(w, u);\\n"
118. " wv = dot(w, v);\\n"
119. " D = uv \* uv - uu \* vv;\\n"
120. "\\n"
121. " float s, t;\\n"
122. "\\n"
123. " s = (uv \* wv - vv \* wu) / D;\\n"
124. " if (s < 0.0 || s > 1.0)\\n"
125. " return false;\\n"
126. " t = (uv \* wu - uu \* wv) / D;\\n"
127. " if (t < 0.0 || (s + t) > 1.0)\\n"
128. " return false;\\n"
129. "\\n"
130. " return true;\\n"
131. "\}\\n"
132. "\\n"
133. "vec3 reflect\_vector(vec3 v, vec3 n)\\n"
134. "\{\\n"
135. " return v - 2.0 \* dot(v, n) \* n;\\n"
136. "\}\\n"
137. "\\n"
138. "void main(void)\\n"
139. "\{\\n"
140. " vec3 accelleration = vec3(0.0, -0.3, 0.0);\\n"
141. " vec3 new\_velocity = velocity + accelleration \* time\_step;\\n"
142. " vec4 new\_position = position + vec4(new\_velocity \* time\_step, 0.0);\\n"
143. " vec3 v0, v1, v2;\\n"
144. " vec3 point;\\n"
145. " int i;\\n"
146. " for (i = 0; i < triangle\_count; i++)\\n"
147. " \{\\n"
148. " v0 = texelFetch(geometry\_tbo, i \* 3).xyz;\\n"
149. " v1 = texelFetch(geometry\_tbo, i \* 3 + 1).xyz;\\n"
150. " v2 = texelFetch(geometry\_tbo, i \* 3 + 2).xyz;\\n"
151. " if (intersect(position.xyz, position.xyz - new\_position.xyz, v0, v1, v2, point))\\n"
152. " \{\\n"
153. " vec3 n = normalize(cross(v1 - v0, v2 - v0));\\n"
154. " new\_position = vec4(point + reflect\_vector(new\_position.xyz - point, n), 1.0);\\n"
155. " new\_velocity = 0.8 \* reflect\_vector(new\_velocity, n);\\n"
156. " \}\\n"
157. " \}\\n"
158. " if (new\_position.y < -80.0)\\n"
159. " \{\\n"
160. " new\_position = vec4(-new\_position.x \* 0.3, position.y + 200.0, 0.0, 1.0);\\n"
161. " new\_velocity \*= vec3(0.2, 0.1, -0.3);\\n"
162. " \}\\n"
163. " velocity\_out = new\_velocity \* 0.9999;\\n"
164. " position\_out = new\_position;\\n"
165. " gl\_Position = projection\_matrix \* (model\_matrix \* position);\\n"
166. "\}\\n"; 
167. 
168. **static****const****char** white\_fs\[\] = 
169. "\#version 410\\n"
170. "\\n"
171. "layout (location = 0) out vec4 color;\\n"
172. "\\n"
173. "void main(void)\\n"
174. "\{\\n"
175. " color = vec4(1.0);\\n"
176. "\}\\n"; 
177. 
178.  vglAttachShaderSource(update\_prog, GL\_VERTEX\_SHADER, update\_vs\_source); 
179.  vglAttachShaderSource(update\_prog, GL\_FRAGMENT\_SHADER, white\_fs); 
180. 
181. **static****const****char**\* varyings\[\] = 
182.  \{ 
183. "position\_out", "velocity\_out"
184.  \}; 
185. 
186.  glTransformFeedbackVaryings( update\_prog, 2, varyings, GL\_INTERLEAVED\_ATTRIBS ); 
187. 
188.  glLinkProgram( update\_prog ); 
189.  glUseProgram( update\_prog ); 
190. 
191.  model\_matrix\_loc = glGetUniformLocation( update\_prog, "model\_matrix" ); 
192.  projection\_matrix\_loc = glGetUniformLocation( update\_prog, "projection\_matrix" ); 
193.  triangle\_count\_loc = glGetUniformLocation( update\_prog, "triangle\_count" ); 
194.  time\_step\_loc = glGetUniformLocation( update\_prog, "time\_step" ); 
195. 
196. //
197.  render\_prog = glCreateProgram(); 
198. 
199. **static****const****char** render\_vs\[\] = 
200. "\#version 410\\n"
201. "\\n"
202. "uniform mat4 model\_matrix;\\n"
203. "uniform mat4 projection\_matrix;\\n"
204. "\\n"
205. "layout (location = 0) in vec4 position;\\n"
206. "layout (location = 1) in vec3 normal;\\n"
207. "\\n"
208. "out vec4 world\_space\_position;\\n"
209. "\\n"
210. "out vec3 vs\_fs\_normal;\\n"
211. "\\n"
212. "void main(void)\\n"
213. "\{\\n"
214. " vec4 pos = (model\_matrix \* (position \* vec4(1.0, 1.0, 1.0, 1.0)));\\n"
215. " world\_space\_position = pos;\\n"
216. " vs\_fs\_normal = normalize((model\_matrix \* vec4(normal, 0.0)).xyz);\\n"
217. " gl\_Position = projection\_matrix \* pos;\\n"
218. "\}\\n"; 
219. 
220. **static****const****char** blue\_fs\[\] = 
221. "\#version 410\\n"
222. "\\n"
223. "layout (location = 0) out vec4 color;\\n"
224. "\\n"
225. "in vec3 vs\_fs\_normal;\\n"
226. "\\n"
227. "void main(void)\\n"
228. "\{\\n"
229. " color = vec4(0.0, 0.2, 0.0, 1.0) + vec4(0.2, 0.5, 0.4, 1.0) \* abs(vs\_fs\_normal.z) + vec4(0.8, 0.9, 0.7, 1.0) \* pow(abs(vs\_fs\_normal.z), 70.0);\\n"
230. "\}\\n"; 
231. 
232.  vglAttachShaderSource( render\_prog, GL\_VERTEX\_SHADER, render\_vs ); 
233.  vglAttachShaderSource(render\_prog, GL\_FRAGMENT\_SHADER, blue\_fs); 
234. 
235. **static****const****char**\* varyings2\[\] = 
236.  \{ 
237. "world\_space\_position"
238.  \}; 
239. 
240.  glTransformFeedbackVaryings( render\_prog, 1, varyings2, GL\_INTERLEAVED\_ATTRIBS ); 
241. 
242.  glLinkProgram( render\_prog ); 
243.  glUseProgram( render\_prog ); 
244. 
245.  render\_model\_matrix\_loc = glGetUniformLocation( render\_prog, "model\_matrix" ); 
246.  render\_projection\_matrix\_loc = glGetUniformLocation( render\_prog, "projection\_matrix" ); 
247. 
248.  glGenVertexArrays( 2, vao ); 
249.  glGenBuffers( 2, vbo ); 
250. 
251. **for** (i = 0; i < 2; i++) 
252.  \{ 
253.  glBindBuffer( GL\_TRANSFORM\_FEEDBACK\_BUFFER, vbo\[i\] ); 
254.  glBufferData( GL\_TRANSFORM\_FEEDBACK\_BUFFER, point\_count \* (**sizeof**(vmath::vec4) + **sizeof**(vmath::vec3) ), NULL, GL\_DYNAMIC\_COPY ); 
255.  GLenum errCode = glGetError(); 
256. 
257. **if** (0 == i) 
258.  \{ 
259. **struct** buffer\_t 
260.  \{ 
261.  vmath::vec4 position; 
262.  vmath::vec3 velocity; 
263.  \}; 
264.  buffer\_t\* buffer = (buffer\_t\*)glMapBuffer( GL\_TRANSFORM\_FEEDBACK\_BUFFER, GL\_WRITE\_ONLY ); 
265. **for** (j = 0; j < point\_count; j++) 
266.  \{ 
267.  buffer\[j\].velocity = random\_vector(); 
268.  buffer\[j\].position = vmath::vec4(buffer\[j\].velocity + vmath::vec3(-0.5f, 120.0f, 0.0f), 1.0f); 
269.  buffer\[j\].velocity = vmath::vec3(buffer\[j\].velocity\[0\], buffer\[j\].velocity\[1\] \* 0.3f, buffer\[j\].velocity\[2\] \* 0.3f); 
270.  \} 
271. 
272.  glUnmapBuffer(GL\_TRANSFORM\_FEEDBACK\_BUFFER); 
273.  \} 
274.  glBindVertexArray(vao\[i\]); 
275.  glBindBuffer( GL\_ARRAY\_BUFFER, vbo\[i\] ); 
276.  glVertexAttribPointer( 0, 4, GL\_FLOAT, GL\_FALSE, **sizeof**(vmath::vec4) + **sizeof**(vmath::vec3), NULL); 
277.  glVertexAttribPointer( 1, 3, GL\_FLOAT, GL\_FALSE, **sizeof**(vmath::vec4) + **sizeof**(vmath::vec3), (GLvoid\*)**sizeof**(vmath::vec4)); 
278.  glEnableVertexAttribArray(0); 
279.  glEnableVertexAttribArray(1); 
280.  \} 
281. 
282.  glGenBuffers( 1, &geometry\_vbo ); 
283.  glGenTextures( 1, &geometry\_tex ); //geometry\_tex没有使用到
284.  glBindBuffer( GL\_TEXTURE\_BUFFER, geometry\_vbo ); 
285.  glBufferData( GL\_TEXTURE\_BUFFER, 1024 \* 1024 \* **sizeof**(vmath::vec4), NULL, GL\_DYNAMIC\_COPY ); 
286.  glBindTexture( GL\_TEXTURE\_BUFFER, geometry\_tex ); //作者好像并没有详细检查代码QAQ,这里根本就写错了
287.  glTexBuffer( GL\_TEXTURE\_BUFFER, GL\_RGBA32F, geometry\_vbo ); 
288. 
289. //感觉后面这个render\_vao根本没意义呀，render\_prog只需要渲染object对象，而object有自身的vao。况且geometry\_vbo没有数据！
290. //在渲染了模型对象才会transform feedback捕获到数据.display过程完全用不到这个render\_vao
291. /\*glGenVertexArrays( 1, &render\_vao );
292.  glBindVertexArray( render\_vao );
293.  glBindBuffer( GL\_ARRAY\_BUFFER, geometry\_vbo );
294.  glVertexAttribPointer( 0, 4, GL\_FLOAT, GL\_FALSE, 0, NULL );
295.  glEnableVertexAttribArray(0);\*/
296. 
297.  glClearColor( 0.0f, 0.0f, 0.0f, 1.0f); 
298.  glClearDepth( 1.0f ); 
299. 
300.  object.LoadFromVBM("../8edlib/media/armadillo\_low.vbm", 0, 1, 2); 
301. 
302. \} 
303. 
304. **void** transformFBDisplay() 
305. \{ 
306. **static****int** frame\_count = 0; 
307. **float** t = **float**(GetTickCount() & 0x3FFFF) / **float**(0x3FFFF); 
308. **static****float** q = 0.0f; 
309. **static****const** vmath::vec3 X( 1.0f, 0.0f, 0.0f ); 
310. **static****const** vmath::vec3 Y( 0.0f, 1.0f, 0.0f ); 
311. **static****const** vmath::vec3 Z( 0.0f, 0.0f, 1.0f ); 
312. 
313.  vmath::mat4 projection\_matrix(vmath::frustum(-1.0f, 1.0f, -aspect, aspect, 1.0f, 5000.0f) \* vmath::translate(0.0f, 0.0f, -100.0f)); 
314.  vmath::mat4 model\_matrix(vmath::scale(0.3f) \* 
315.  vmath::rotate(t \* 360.0f, 0.0f, 1.0f, 0.0f) \* 
316.  vmath::rotate(t \* 360.0f \* 3.0f, 0.0f, 0.0f, 1.0f)); 
317. 
318.  glClear( GL\_COLOR\_BUFFER\_BIT | GL\_DEPTH\_BUFFER\_BIT ); 
319. 
320.  glEnable( GL\_CULL\_FACE ); 
321.  glEnable( GL\_DEPTH\_TEST ); 
322.  glDepthFunc( GL\_LEQUAL ); 
323. 
324.  glUseProgram( render\_prog ); 
325.  glUniformMatrix4fv( render\_model\_matrix\_loc, 1, GL\_FALSE, model\_matrix ); 
326.  glUniformMatrix4fv( render\_projection\_matrix\_loc, 1, GL\_FALSE, projection\_matrix ); 
327. 
328.  glBindVertexArray( render\_vao ); 
329. 
330.  glBindBufferBase( GL\_TRANSFORM\_FEEDBACK\_BUFFER, 0, geometry\_vbo ); 
331. 
332.  glBeginTransformFeedback( GL\_TRIANGLES ); 
333.  object.Render(); 
334.  glEndTransformFeedback(); 
335. 
336.  glUseProgram( update\_prog ); 
337.  model\_matrix = vmath::mat4::identity(); 
338.  glUniformMatrix4fv( model\_matrix\_loc, 1, GL\_FALSE, model\_matrix ); 
339.  glUniformMatrix4fv( projection\_matrix\_loc, 1, GL\_FALSE, projection\_matrix ); 
340.  glUniform1i( triangle\_count\_loc, object.GetVertexCount()/3 ); 
341. 
342. **if** (t > q) 
343.  \{ 
344.  glUniform1f(time\_step\_loc, 0.2f); 
345. //glUniform1f( time\_step\_loc, (t-q)\*2000.0f );
346. **static****TCHAR** debugStr\[4096\] = L""; 
347.  swprintf\_s(debugStr, L" FrameCount = %.3f\\n", t); 
348.  OutputDebugString(debugStr); 
349.  \} 
350.  q = t; 
351. **if** ((frame\_count & 1) != 0) 
352.  \{ 
353.  glBindVertexArray( vao\[1\] ); 
354.  glBindBufferBase( GL\_TRANSFORM\_FEEDBACK\_BUFFER, 0, vbo\[0\] ); 
355.  \} 
356. **else**
357.  \{ 
358.  glBindVertexArray( vao\[0\] ); 
359.  glBindBufferBase( GL\_TRANSFORM\_FEEDBACK\_BUFFER, 0, vbo\[1\] ); 
360.  \} 
361. 
362.  glBeginTransformFeedback( GL\_POINTS ); 
363.  glDrawArrays(GL\_POINTS, 0, point\_count/\*min(point\_count, frame\_count >> 2 )\*/); 
364.  glEndTransformFeedback(); 
365. 
366.  glBindVertexArray(0); 
367. 
368. 
369.  frame\_count++; 
370. 
371. \} 
372. 
373. **void** transformFBUpdate(**float** delta) 
374. \{ 
375. 
376. \}

[http_www.zwqxin.com_archives_opengl_talk-about-transform-feedback.html]: http://www.zwqxin.com/archives/opengl/talk-about-transform-feedback.html
[Center]: /images/20220731/9b4591bfb9d3426ab538820b3db5d747.png
[Center 1]: /images/20220731/a6c309f2f76c4390b9dc5c5327ec0355.png
[Center 2]: /images/20220731/fd89c94557224c73b57c407dcf9b8769.png
[Center 3]: /images/20220731/3819849b3c6f4405876d020c50020915.png
[view plain]: http://blog.csdn.net/coderling/article/details/44742077#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/632027
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/632027/fork