鬼の领地 » OpenGL http://blog.upsuper.org the place where there are some ghost appearing... Wed, 19 Oct 2011 13:21:47 +0000 en hourly 1 http://wordpress.org/?v=3.3 OpenGL 的小试验（五） http://blog.upsuper.org/opengl-small-test-5/ http://blog.upsuper.org/opengl-small-test-5/#comments Mon, 23 Mar 2009 03:31:48 +0000 upsuper http://blog.upsuper.org/?p=707 myballs在对光照和面的消除以及碰撞检测进行了些许研究后，改进的 3D Demo 再次出炉。

这次的立体感更强了，因为加入了光照去掉了混合并加上了深度测试。不过开始的时候，因为去掉了混合，不能搞半透明了，本来想直接判断视角然后不绘制立方体相应的面，结果后来无意中发现一个叫做 glCullFace 的东西可以直接去掉某一个平面的一个面（变成透明），于是就把它施在了那个立方体上。（当时参考的资料找不到了……）这样就有了这一个效果：你总是看到你本来看不到的面。

接着就是加光照。不用 CullFace 的情况下，光照没问题，可是一开就变得十分黯淡，不懂得为什么……开始觉得是不是这两个会冲突，但想想又觉得这两个没道理冲突啊……后来终于想到了——法线，因为法线是为外面的面设置的（朝向立方体外），我把所有法线掉一个头，瞬间效果就出来了……

球什么的还按照原来的方法加好。这次的挑战其实主要是那个碰撞检测。我想了很久，觉得要几乎真实的模拟只有通过大规模的计算进行逐个测试，于是我就这么做了……但事实证明，这样做虽然效果看起来不差，不过由于有碰撞和没碰撞时计算量差异可能非常大，以致瞬间造成“卡”的感觉，同时，我发现所有球停下来后，会叠在一起，而不会像真实那样下面的滚开让上面的下来。不过后面这个就现在的模型来说也没什么办法，因为本来就不是模拟力的，只模拟了个加速度……至于前面那个，我暂时也没想出什么好办法解决，或许可以用一些更简陋的方法来计算，以求更高的速度？

在 3D 中速度才是王道啊……

这次还加入了即时显示 fps 的东西，试用了 Google 的 DroidSans 开源字体，体积上还是相当不错的~我基本上是设置了每 0.15s 更新一次显示的 fps。

最后，因为希望整个程序结构清晰一些，把原来的一大个文件分成了好多文件，所以这次必须打包了……还因此顺便又尝试写了个比较大的 Makefile……

最最后是下载地址：myballs.rar (100.45 KB)

]]> http://blog.upsuper.org/opengl-small-test-5/feed/ 1 OpenGL 的小试验（四） http://blog.upsuper.org/opengl-small-test-4/ http://blog.upsuper.org/opengl-small-test-4/#comments Tue, 24 Feb 2009 12:10:57 +0000 upsuper http://blog.upsuper.org/?p=701 test21花了几天完全自己写了个小小的 Demo，本来想把球与球之间的碰撞也写出来的，结果写的太 bug 了，就暂时算了，先发这个了……

由于这个主要在学校完成，所以就只生成了 for Windows 的版本。同时，为了稍微推广一下，还写了个前端……

编译好的版本：test2.exe
前端：test2_ui.exe
把这两个放在一个目录就可以用了……

这一次基本没再参考什么教程，不过等到我发觉我再也写不下去的时候，我才发现其实我要学的东西还很多。写这个看来要有相当好的数学和物理基础，特别是计算几何和运动学（我物理中最差的恰是运动学……）。这次的程序加入了许多控制键，模拟重力效果个人是比较满意的，显示效果等到以后学了再做得更好。

额外的，这个程序会在命令行中输出帧数，本来是用以测试一些优化是否有效的，这下也可以小试一下显卡。

还是先贴程序，编译方法见上一篇中的介绍。这次程序已经过500行了，不过个人感觉程序结构的组织还是比较有序的。中间注释掉的那一大段就是我写的很萎的两球相碰。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <time.h>
#include <GL/glfw.h>
 
const GLfloat PI = GLfloat(3.14159265358979323846264338327950288);
 
struct point
{
	int x, y;
};
 
struct ball
{
	GLfloat x, y, z;
	GLfloat r, g, b;
	GLfloat vx, vy, vz;
};
 
int width = 0, height = 0;
bool fullscreen = true;
bool active = true;
bool keys[GLFW_KEY_LAST+1];
 
bool no_gravity = false, no_collision_between_sphere = false;
GLfloat speed = 1.0f;
 
GLUquadricObj* quadratic;
 
int ball_number = 10;
point origin;
ball *balls;
 
GLfloat gravity = 0.001f;
GLfloat radius = 0.1f, diameter;
int sphere_ss;
GLfloat rx, ry, zoom;
GLfloat boxsize, hb;
GLfloat room1, room2;
 
int frames = 0;
double starttime;
 
int i, j;
 
bool initGLFW(const char*, int, int);
 
inline GLfloat d2r(GLfloat degree)
{
	return degree / 180.0f * PI;
}
 
inline void xAdd(ball &b, GLfloat dist)
{
	GLfloat ryd = d2r(ry);
	b.vx += GLfloat(cos(ryd)) * dist;
	b.vz += -GLfloat(sin(ryd)) * dist;
}
 
inline void yAdd(ball &b, GLfloat dist)
{
	GLfloat rxd = d2r(rx), ryd = d2r(ry);
	b.vy += GLfloat(cos(rxd)) * dist;
	dist *= GLfloat(sin(rxd));
	b.vx += GLfloat(sin(ryd)) * dist;
	b.vz += GLfloat(cos(ryd)) * dist;
}
 
inline void zAdd(ball &b, GLfloat dist)
{
	GLfloat rxd = -d2r(rx), ryd = d2r(ry);
	b.vy += GLfloat(sin(rxd)) * dist;
	dist *= GLfloat(cos(rxd));
	b.vx += GLfloat(sin(ryd)) * dist;
	b.vz += GLfloat(cos(ryd)) * dist;
}
 
inline GLfloat randf()
{
	return GLfloat(rand()) / RAND_MAX;
}
 
void initBalls()
{
	for (i = 0; i < ball_number; ++i)
	{
		if (! no_collision_between_sphere)
		{
			int try_count = 0;
			GLfloat tx, ty, tz;
			while (try_count <= 10)
			{
 
				++try_count;
				tx = randf() * room1 - room2;
				ty = randf() * room1 - room2;
				tz = randf() * room1 - room2;
				bool ok_flag = true;
				for (j = 0; j < i; ++j)
				{
					GLfloat dx = balls[j].x - tx,
							dy = balls[j].y - ty,
							dz = balls[j].z - tz;
					dx *= dx; dy *= dy; dz *= dz;
					GLfloat dist = GLfloat(sqrt(dx + dy + dz));
					if (dist < diameter)
					{
						ok_flag = false;
						break;
					}
				}
				if (ok_flag) break;
			}
			if (try_count > 10)
			{
				printf("Error: I cannot build more than %d ball%s.\n", 
					i, i > 1 ? "s" : "");
				ball_number = i;
				break;
			}
			balls[i].x = tx; balls[i].y = ty; balls[i].z = tz;
		}
		else
		{
			balls[i].x = randf() * room1 - room2;
			balls[i].y = randf() * room1 - room2;
			balls[i].z = randf() * room1 - room2;
		}
		balls[i].vx = 0.0f;
		balls[i].vy = 0.0f;
		balls[i].vz = 0.0f;
		balls[i].r = randf();
		balls[i].g = randf();
		balls[i].b = randf();
	}
}
 
void caleBalls()
{
	if (keys[GLFW_KEY_HOME]) return;
 
	for (i = 0; i < ball_number; ++i)
	{
		if (! no_gravity) yAdd(balls[i], -gravity);
		balls[i].x += balls[i].vx * speed;
		balls[i].y += balls[i].vy * speed;
		balls[i].z += balls[i].vz * speed;
 
		if (balls[i].y <= -room2)
		{
			balls[i].y = -room2 * 2 - balls[i].y;
			balls[i].vy = -balls[i].vy;
		}
		else if (balls[i].y >= room2)
		{
			balls[i].y = room2 * 2 - balls[i].y;
			balls[i].vy = -balls[i].vy;
		}
 
		if (balls[i].x <= -room2)
		{
			balls[i].x = -room2 * 2 - balls[i].x;
			balls[i].vx = -balls[i].vx;
		}
		else if (balls[i].x >= room2)
		{
			balls[i].x = room2 * 2 - balls[i].x;
			balls[i].vx = -balls[i].vx;
		}
 
		if (balls[i].z <= -room2)
		{
			balls[i].z = -room2 * 2 - balls[i].z;
			balls[i].vz = -balls[i].vz;
		}
		else if (balls[i].z >= room2)
		{
			balls[i].z = room2 * 2 - balls[i].z;
			balls[i].vz = -balls[i].vz;
		}
 
		/*for (j = 0; j < i; ++j)
		{
			GLfloat dx = balls[i].x - balls[j].x,
					dy = balls[i].y - balls[j].y,
					dz = balls[i].z - balls[j].z;
			GLfloat dsq = dx * dx + dy * dy + dz * dz;
			GLfloat dist = GLfloat(sqrt(dsq));
			GLfloat lamda;
			if (dist >= diameter) continue;
 
			lamda = (balls[i].vx * dx
					+ balls[i].vy * dy
					+ balls[i].vz * dz) / dsq;
			GLfloat tx1 = lamda * dx,
					ty1 = lamda * dy,
					tz1 = lamda * dz;
			balls[i].vx -= tx1;
			balls[i].vy -= ty1;
			balls[i].vz -= tz1;
 
			lamda = (balls[j].vx * dx
					+ balls[j].vy * dy
					+ balls[j].vz * dz) / dsq;
			GLfloat tx2 = lamda * dx,
					ty2 = lamda * dy,
					tz2 = lamda * dz;
			balls[j].vx -= tx2;
			balls[j].vy -= ty2;
			balls[j].vz -= tz2;
 
			balls[i].vx += tx2;
			balls[i].vy += ty2;
			balls[i].vz += tz2;
			balls[j].vx += tx1;
			balls[j].vy += ty1;
			balls[j].vz += tz1;
 
			dist = (diameter / dist - 1) * 2;
			dsq = GLfloat(fabs(dx * dist));
			if (balls[i].vx * balls[j].vx < 0)
				dsq /= GLfloat(fabs(balls[i].vx) + fabs(balls[j].vx));
			balls[i].x += balls[i].vx * dsq * speed;
			balls[j].x += balls[j].vx * dsq * speed;
 
			dsq = GLfloat(fabs(dy * dist));
			if (balls[i].vy * balls[j].vy < 0)
				dsq /= GLfloat(fabs(balls[i].vy) + fabs(balls[j].vy));
			balls[i].y += balls[i].vy * dsq * speed;
			balls[j].y += balls[j].vy * dsq * speed;
 
			dsq = GLfloat(fabs(dz * dist));
			if (balls[i].vz * balls[j].vz < 0)
				dsq /= GLfloat(fabs(balls[i].vz) + fabs(balls[j].vz));
			balls[i].z += balls[i].vz * dsq * speed;
			balls[j].z += balls[j].vz * dsq * speed;
		}*/
	}
}
 
void printFPS()
{
	++frames;
	double dt = glfwGetTime() - starttime;
	if (dt >= 5.0)
	{
		printf("%d frames in %3.1f seconds = %6.3f FPS\n", 
			frames, dt, double(frames) / dt);
		frames = 0; starttime = glfwGetTime();
	}
}
 
void drawGLScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glLoadIdentity();
	glTranslatef(0.0, 0.0, -zoom);
	glRotatef(-rx, 1.0, 0.0, 0.0);
	glRotatef(-ry, 0.0, 1.0, 0.0);
 
	glBegin(GL_QUADS);
		glColor4f(0.0f, 0.0f, 0.5f, 0.3f);
		glVertex3f(-hb, -hb,  hb);
		glVertex3f( hb, -hb,  hb);
		glVertex3f( hb,  hb,  hb);
		glVertex3f(-hb,  hb,  hb);
 
		glColor4f(0.0f, 0.5f, 0.0f, 0.3f);
		glVertex3f( hb, -hb,  hb);
		glVertex3f( hb, -hb, -hb);
		glVertex3f( hb,  hb, -hb);
		glVertex3f( hb,  hb,  hb);
 
		glColor4f(0.5f, 0.0f, 0.0f, 0.3f);
		glVertex3f(-hb,  hb,  hb);
		glVertex3f( hb,  hb,  hb);
		glVertex3f( hb,  hb, -hb);
		glVertex3f(-hb,  hb, -hb);
 
		glColor4f(0.0f, 0.5f, 0.0f, 0.3f);
		glVertex3f(-hb, -hb, -hb);
		glVertex3f(-hb, -hb,  hb);
		glVertex3f(-hb,  hb,  hb);
		glVertex3f(-hb,  hb, -hb);
 
		glColor4f(0.0f, 0.0f, 0.5f, 0.3f);
		glVertex3f( hb, -hb, -hb);
		glVertex3f(-hb, -hb, -hb);
		glVertex3f(-hb,  hb, -hb);
		glVertex3f( hb,  hb, -hb);
 
		glColor4f(0.7f, 0.7f, 0.7f, 0.5f);
		glVertex3f(-hb, -hb, -hb);
		glVertex3f( hb, -hb, -hb);
		glVertex3f( hb, -hb,  hb);
		glVertex3f(-hb, -hb,  hb);
	glEnd();
 
	caleBalls();
 
	for (i = 0; i < ball_number; ++i)
	{
		glTranslatef(balls[i].x, balls[i].y, balls[i].z);
		glColor4f(balls[i].r, balls[i].g, balls[i].b, 1.0f);
		gluSphere(quadratic, radius, sphere_ss, sphere_ss);
		glTranslatef(-balls[i].x, -balls[i].y, -balls[i].z);
	}
 
	printFPS();
 
}
 
void keyPress(int key, int action)
{
	keys[key] = action ? true : false;
 
	if (keys[GLFW_KEY_ESC])
	{
		active = false;
		return;
	}
 
	if (keys[GLFW_KEY_F11])
	{
		keys[GLFW_KEY_F11] = GLFW_RELEASE;
		glfwTerminate();
		fullscreen = ! fullscreen;
		initGLFW("Upsuper's OpenGL Test", width, height);
	}
}
 
void keyPress() {
	if (keys[GLFW_KEY_KP_ADD]) zoom -= 0.1f;
	if (keys[GLFW_KEY_KP_SUBTRACT]) zoom += 0.1f;
 
	if (keys[GLFW_KEY_PAGEUP])
		for (i = 0; i < ball_number; ++i)
			yAdd(balls[i], gravity * 3);
	if (keys[GLFW_KEY_PAGEDOWN])
		for (i = 0; i < ball_number; ++i)
			yAdd(balls[i], -gravity * 3);
	if (keys[GLFW_KEY_UP])
		for (i = 0; i < ball_number; ++i)
			zAdd(balls[i], -gravity * 3);
	if (keys[GLFW_KEY_DOWN])
		for (i = 0; i < ball_number; ++i)
			zAdd(balls[i], gravity * 3);
	if (keys[GLFW_KEY_LEFT])
		for (i = 0; i < ball_number; ++i)
			xAdd(balls[i], -gravity * 3);
	if (keys[GLFW_KEY_RIGHT])
		for (i = 0; i < ball_number; ++i)
			xAdd(balls[i], gravity * 3);
 
	if (keys[GLFW_KEY_HOME])
		for (i = 0; i < ball_number; ++i)
			balls[i].vx = balls[i].vy = balls[i].vz = 0.0;
}
 
void checkDegree(GLfloat &degree)
{
	if (degree > 180.0f) degree -= 360.0;
	else if (degree < -180.f) degree += 360.0;
}
 
void mouseMove(int x, int y)
{
	int dx = x - origin.x,
		dy = y - origin.y;
	glfwSetMousePos(origin.x, origin.y);
	checkDegree(rx += GLfloat(dy) / 5.0f);
	checkDegree(ry += GLfloat(dx) / 5.0f);
}
 
inline void quit(int status)
{
	glfwTerminate();
	exit(status);
}
 
inline void quit() {
	quit(0);
}
 
inline void report_error(const char* info)
{
	puts(info);
	quit(1);
}
 
void resizeGLScene(int width, int height)
{
	if (height <= 0) height = 1;
 
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, GLfloat(width)/GLfloat(height), 0.1, 100.0);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
bool initGL(int width, int height)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glClearDepth(1.0);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glDisable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 
	quadratic = gluNewQuadric();
	gluQuadricNormals(quadratic, GLU_SMOOTH);
	gluQuadricTexture(quadratic, GL_TRUE);
 
	return true;
}
 
bool initGLFW(const char* title, int width, int height)
{
	glfwInit();
	glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, true);
	if (! glfwOpenWindow(width, height, 8, 8, 8, 8, 24, 0, 
			fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW))
		report_error("ERROR: Cannot open a window.");
	glfwSetWindowTitle(title);
	glfwSetWindowPos(0, 0);
 
	origin.x = width / 2; origin.y = height / 2;
	glfwSetMousePos(origin.x, origin.y);
	glfwDisable(GLFW_MOUSE_CURSOR);
	glfwSetMousePosCallback(mouseMove);
 
	glfwEnable(GLFW_AUTO_POLL_EVENTS);
	glfwSetKeyCallback(keyPress);
	glfwSetWindowSizeCallback(resizeGLScene);
 
	initGL(width, height);
 
	return true;
}
 
int main(int argc, char* argv[])
{
	for (i = 1; i < argc; ++i)
	{
		if (strcmp(argv[i], "--window-mode") == 0)
			fullscreen = false;
		else if (strcmp(argv[i], "--no-gravity") == 0)
			no_gravity = true;
		else if (strcmp(argv[i], "--no-collision-between-sphere") == 0)
			no_collision_between_sphere = true;
		else if (strcmp(argv[i], "--width") == 0)
			width = atoi(argv[++i]);
		else if (strcmp(argv[i], "--height") == 0)
			height = atoi(argv[++i]);
		else if (strcmp(argv[i], "--number") == 0)
			ball_number = atoi(argv[++i]);
		else if (strcmp(argv[i], "--box-size") == 0)
			boxsize = GLfloat(atof(argv[++i]));
		else if (strcmp(argv[i], "--gravity") == 0)
			gravity = GLfloat(atof(argv[++i]));
		else if (strcmp(argv[i], "--radius") == 0)
			radius = GLfloat(atof(argv[++i]));
		else if (strcmp(argv[i], "--speed") == 0)
			speed = GLfloat(atof(argv[++i]));
 
	}
 
	if (boxsize == 0.0f) boxsize = 5.0f;
	balls = new ball[ball_number];
 
	diameter = radius * 2;
	sphere_ss = int(sqrt(radius) * 72);
	hb = boxsize / 2;
	zoom = boxsize * 2;
	srand(time(NULL));
	room1 = boxsize - diameter;
	room2 = room1 / 2;
	initBalls();
 
	initGLFW("Upsuper's OpenGL Demo -- Some Balls", width, height);
 
	starttime = glfwGetTime();
	do
	{
		drawGLScene();
		glfwSwapBuffers();
		keyPress();
	}
	while (active);
 
	quit();
	return 0;
}
]]> http://blog.upsuper.org/opengl-small-test-4/feed/ 0 OpenGL 的小试验（三） http://blog.upsuper.org/opengl-small-test-3/ http://blog.upsuper.org/opengl-small-test-3/#comments Sat, 21 Feb 2009 15:53:01 +0000 upsuper http://blog.upsuper.org/?p=695 screenshot-opengl今天回家本想在我的 Ubuntu 上玩玩 OpenGL，结果花了一个下午，终于研究出些东西了……

在 NeHe 的源代码中似乎有 Linux 的，不过一个是用 glut、一个是用 SDL、一个是用 GLX，原本看到 glut 是 OpenGL 官方的一个夸平台的简单窗口系统，结果发现全屏不能……于是就找到了 GLFW 这个东西，据说比较简单，不过还是研究了一个下午。

下面说一下研究成果吧，首先，想要用 g++ 编译用 GLFW 写的程序，一定要加这些编译参数： -lglfw -lGL -lGLU -lXrandr，特别是最后一个，是其官方参考中没有的！这个是我查了许多资料，然后瞎猜猜到的……再说说头文件，这次不需要引用3个库了，只有一个 #include <GL/glfw.h> 就可以了，似乎把其他的库自动引用了。另外就是，画完要用 glfwSwapBuffers(); 刷新，不然不仅什么都不会显示，而且还会死机……除此之外，还要注意那个键盘的按键，不要想当然的和 Windows 下拿去类比，根据研究发现，键盘事件交出的 key 最大可以达到 318，而且特殊键都会以这些“大值”返回，所以一定要申请好内存……

这次主要参考了：
GLFW Reference
OpenGL Tutorials – Basics
以及 NeHe 的 OpenGL 教程。

这个例子是一个转动的彩色四棱锥，只有 ESC 和 F11 的键盘处理，附加帧数计算。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <GL/glfw.h>
 
bool fullscreen;
bool active = true;
bool keys[GLFW_KEY_LAST+1]; // 为键盘按键申请空间
 
GLfloat rtri;
 
bool initGLFW(const char*, int, int);
 
// 帧数统计用
double starttime;
int flames = 0;
 
// 绘制代码
void drawGLScene()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
 
	glTranslatef(0.0f, 0.0f, -5.0f);
	glRotatef(rtri, 0.0f, 1.0f, 0.0f);
	glBegin(GL_TRIANGLES);
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f); glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
	glEnd();
 
	++flames;
	double dt = glfwGetTime() - starttime;
	if (dt >= 5.0f)
	{
		printf("%d frames in %.1lf seconds = %.3lf FPSn", flames, dt, double(flames) / dt);
		flames = 0;
		st = glfwGetTime();
	}
 
	rtri += 0.15f;
}
 
// 键盘处理
void keyPress(int key, int action)
{
	keys[key] = action;
 
	if (keys[GLFW_KEY_ESC])
	{
		active = false;
		return;
	}
 
	if (keys[GLFW_KEY_F11])
	{
		keys[GLFW_KEY_F11] = GLFW_RELEASE;
		glfwTerminate();
		fullscreen = ! fullscreen;
		initGLFW("Upsuper's OpenGL Test", 640, 480);
	}
}
 
inline void quit(int status)
{
	glfwTerminate();
	exit(status);
}
 
inline void quit() {
	quit(0);
}
 
inline void report_error(const char* info)
{
	puts(info);
	quit(1);
}
 
void resizeGLScene(int width, int height)
{
	if (height <= 0) height = 1;
 
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, GLfloat(width)/GLfloat(height), 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
bool initGL(int width, int height)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	return true;
}
 
bool initGLFW(const char* title, int width, int height)
{
	glfwInit();
	if (! glfwOpenWindow(width, height, 8, 8, 8, 8, 24, 0, 
			fullscreen ? GLFW_FULLSCREEN : GLFW_WINDOW))
		report_error("ERROR: Cannot open a window.");
	glfwSetWindowTitle(title);
	glfwEnable(GLFW_AUTO_POLL_EVENTS);
	glfwSetKeyCallback(keyPress);
	glfwSetWindowSizeCallback(resizeGLScene);
 
	initGL(width, height);
}
 
int main(int argc, char** argv)
{
	printf("Would you like to run in fullscreen mode? [Y/n]");
	int c = getchar();
	fullscreen = (c != 'n' && c != 'N');
 
	memset(keys, false, sizeof(keys));
	initGLFW("Upsuper's OpenGL Test", 640, 480);
 
	st = glfwGetTime();
	do
	{
		drawGLScene();
		glfwSwapBuffers();
	}
	while (active);
 
	quit();
	return 0;
}

代码比 VC++ 的那个短好多，再次证明 Linux 是多么适用于编程……

同时根据帧数对比，印证了我的猜想——全屏下比较流畅！我这里全屏下 fps 达到了窗口模式的接近3倍。

附 makefile 文件（这也是我第一次写 makefile）：

1
2

all: test1.cpp a.cpp
	g++ test1.cpp -o test1 -lglfw -lGL -lGLU -lXrandr

最后，我还是十分高兴，那个绘制代码是我自己写出来的，不是抄的了！（虽然以前写过……）

写 OpenGL 就是爽……

]]> http://blog.upsuper.org/opengl-small-test-3/feed/ 0 OpenGL 的小试验（二） http://blog.upsuper.org/opengl-small-test-2/ http://blog.upsuper.org/opengl-small-test-2/#comments Fri, 20 Feb 2009 11:49:23 +0000 upsuper http://blog.upsuper.org/?p=692 test2今天又玩了玩，感觉到 OpenGL 实在太强大了！我也第一次遭到了买好显卡的重要意义：可以写 OpenGL 的程序！右边是效果图，有半透明、点光源效果。其实动起来会比较炫一点。

参考了下面教程（其实主要是抄）：
OpenGL教程之纹理映射
OpenGL教程之纹理滤波方式
OpenGL教程之Alpha混合

除了教程里的功能，我还增加了按空格停止和按回车复位两个无聊功能……

整个程序也已经由上一篇的将近400行增加到了超过500行。不过和新的的优美效果比起来，这点代码似乎不算什么~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519

#include <windows.h>
#include <stdio.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
 
HGLRC hRC = NULL;
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;
 
bool keys[256];
bool active = true;
bool fullscreen = true;
 
bool light, blend, lp, fp, bp, f11p;
 
GLfloat xrot, yrot, zrot;
GLfloat xspeed, yspeed;
GLfloat z = -5.0f;
 
GLfloat lightAmbient[] = { 0.5f, 0.5f, 0.5f, 1.0f };
GLfloat lightDiffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat lightPosition[] = { 0.0f, 0.0f, 2.0f, 1.0f };
 
GLuint filter;
GLuint texture[3];
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
AUX_RGBImageRec *LoadBMP(char *filename)
{
	FILE *file = NULL;
	if (! filename) return NULL;
	file = fopen(filename, "r");
	if (! file) return NULL;
	fclose(file);
	return auxDIBImageLoad(filename);
}
 
int LoadGLTextures()
{
	int status = false;
	AUX_RGBImageRec *textureImage[1];
	memset(textureImage, 0, sizeof(void*)*1);
 
	if (textureImage[0] = LoadBMP("test2.bmp"))
	{
		status = true;
		glGenTextures(1, &texture[0]);
		glBindTexture(GL_TEXTURE_2D, texture[0]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, 
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			0, GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
 
		glBindTexture(GL_TEXTURE_2D, texture[1]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, 
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			0, GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
 
		glBindTexture(GL_TEXTURE_2D, texture[2]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
		gluBuild2DMipmaps(GL_TEXTURE_2D, 3,
			textureImage[0]->sizeX, textureImage[0]->sizeY,
			GL_RGB, GL_UNSIGNED_BYTE, textureImage[0]->data);
	}
 
	if (textureImage[0])
	{
		if (textureImage[0]->data)
			free(textureImage[0]->data);
		free(textureImage[0]);
	}
 
	return status;
}
 
GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height == 0)
		height = 1;
	glViewport(0, 0, width, height);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
int InitGL(GLvoid)
{
	if (! LoadGLTextures())
		return false;
 
	glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 
	glEnable(GL_TEXTURE_2D);
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
	glLightfv(GL_LIGHT1, GL_AMBIENT, lightAmbient);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, lightDiffuse);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition);
	glEnable(GL_LIGHT1);
 
	return true;
}
 
int DrawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glLoadIdentity();
	glTranslatef(0.0f, 0.0f, z);
	glRotatef(xrot, 1.0f, 0.0f, 0.0f);
	glRotatef(yrot, 0.0f, 1.0f, 0.0f);
	//glRotatef(zrot, 0.0f, 0.0f, 1.0f);
	glColor3f(1.0f, 1.0f, 1.0f);
	glBindTexture(GL_TEXTURE_2D, texture[filter]);
	glBegin(GL_QUADS);
		glNormal3f(0.0f, 0.0f, 1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
 
		glNormal3f(0.0f, 0.0f, -1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glNormal3f(0.0f, 1.0f, 0.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
 
		glNormal3f(0.0f, -1.0f, 0.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glNormal3f(1.0f, 0.0f, 0.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glNormal3f(-1.0f, 0.0f, 0.0f);
		glTexCoord2f(0.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glTexCoord2f(1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glTexCoord2f(1.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glTexCoord2f(0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
	glEnd();
 
	//xrot += 0.3f, yrot += 0.2f, zrot += 0.4f;
	xrot += xspeed;
	yrot += yspeed;
 
	return true;
}
 
GLvoid KillGLWindow(GLvoid)
{
	if (fullscreen)
	{
		ChangeDisplaySettings(NULL, 0);
		ShowCursor(true);
	}
 
	if (hRC)
	{
		if (! wglMakeCurrent(NULL, NULL))
			MessageBox(NULL, "Release Of DC And RC Failed.",
				"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		if (! wglDeleteContext(hRC))
			MessageBox(NULL, "Release Rendering Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hRC = NULL;
	}
 
	if (hDC && ! ReleaseDC(hWnd, hDC))
	{
		MessageBox(NULL, "Release Device Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hDC = NULL;
	}
 
	if (hWnd && ! DestroyWindow(hWnd))
	{
		MessageBox(NULL, "Could Not Release hWnd.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hWnd = NULL;
	}
}
 
bool CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint PixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle;
	DWORD dwStyle;
 
	RECT windowRect;
	windowRect.left = (long)0;
	windowRect.right = (long)width;
	windowRect.top = (long)0;
	windowRect.bottom = (long)height;
 
	fullscreen = fullscreenflag;
 
	hInstance = GetModuleHandle(NULL);
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = (WNDPROC) WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "OpenGL";
 
	if (! RegisterClass(&wc))
	{
		MessageBox(NULL, "Failed To Register The Windows Class.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth = width;
		dmScreenSettings.dmPelsHeight = height;
		dmScreenSettings.dmBitsPerPel = bits;
		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
 
		if (ChangeDisplaySettings(&dmScreenSettings, 
			CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL, 
				"The Requested Fullscreen Mode Is Not Supported By Your Video Card. Use Windowed Mode Instead?",
				"OpenGL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				fullscreen = false;
			}
			else
			{
				MessageBox(NULL, "Program Will Now Close.",
					"ERROR", MB_OK | MB_ICONSTOP);
				return false;
			}
		}
	}
 
	if (fullscreen)
	{
		dwExStyle = WS_EX_APPWINDOW;
		dwStyle = WS_POPUP;
		ShowCursor(false);
	}
	else
	{
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle = WS_OVERLAPPEDWINDOW;
	}
	AdjustWindowRectEx(&windowRect, dwStyle, false, dwExStyle);
 
	if (! (hWnd = CreateWindowEx(dwExStyle, "OpenGL", title,
		WS_CLIPSIBLINGS | WS_CLIPCHILDREN | dwStyle, 0, 0,
		windowRect.right - windowRect.left,
		windowRect.bottom - windowRect.top,
		NULL, NULL, hInstance, NULL)))
	{
		KillGLWindow();
		MessageBox(NULL, "Window Creation Error.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	static PIXELFORMATDESCRIPTOR pfd = 
	{
		sizeof(PIXELFORMATDESCRIPTOR), 1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA, bits, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	};
 
	if (! (hDC = GetDC(hWnd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Device Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (PixelFormat = ChoosePixelFormat(hDC, &pfd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Find A Suitable PixelFormat.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! SetPixelFormat(hDC, PixelFormat, &pfd))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (hRC = wglCreateContext(hDC)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! wglMakeCurrent(hDC, hRC))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Activate The GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);
 
	if (! InitGL())
	{
		KillGLWindow();
		MessageBox(NULL, "Initialization Failed.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	return true;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_ACTIVATE:
		active = ! HIWORD(wParam);
		return 0;
	case WM_SYSCOMMAND:
		switch (wParam)
		{
		case SC_SCREENSAVE: 
		case SC_MONITORPOWER:
			return 0;
		}
		break;
	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
		keys[wParam] = true;
		return 0;
	case WM_KEYUP:
		keys[wParam] = false;
		return 0;
	case WM_SIZE:
		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		return 0;
	}
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	bool done = false;
 
	fullscreen = (MessageBox(NULL, 
		"Would You Like To Run In Fullscreen Mode?",
		"Start Fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDYES);
	if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
		return 0;
 
	while (! done)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				done = true;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if (active)
			{
				if (keys[VK_ESCAPE])
					done = true;
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
					if (keys['L'] && !lp)
					{
						lp = true;
						light = ! light;
						if (! light)
							glDisable(GL_LIGHTING);
						else
							glEnable(GL_LIGHTING);
					}
					else if (! keys['L'])
						lp = false;
 
					if (keys['F'] && !fp)
					{
						fp = true;
						filter += 1;
						if (filter > 2) filter = 0;
					}
					else if (! keys['F'])
						fp = false;
 
					if (keys['B'] && !bp)
					{
						bp = true;
						blend = ! blend;
						if (blend)
						{
							glEnable(GL_BLEND);
							glDisable(GL_DEPTH_TEST);
						}
						else
						{
							glDisable(GL_BLEND);
							glEnable(GL_DEPTH_TEST);
						}
					}
					else if (! keys['B'])
						bp = false;
 
					if (keys[VK_F11] && !f11p)
					{
						f11p = true;
						KillGLWindow();
						fullscreen = ! fullscreen;
						if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
							return 0;
					}
					else if (!keys[VK_F11])
						f11p = false;
 
					if (keys[VK_PRIOR]) z -= 0.02f;
					if (keys[VK_NEXT]) z += 0.02f;
 
					if (keys[VK_UP]) xspeed -= 0.01f;
					if (keys[VK_DOWN]) xspeed += 0.01f;
					if (keys[VK_RIGHT]) yspeed += 0.01f;
					if (keys[VK_LEFT]) yspeed -= 0.01f;
 
					if (keys[' ']) xspeed = 0.0f, yspeed = 0.0f;
					if (keys[13]) z = -5.0f;
				}
			}
		}
	}
 
	KillGLWindow();
	return (msg.wParam);
}
]]> http://blog.upsuper.org/opengl-small-test-2/feed/ 0 OpenGL 的小试验（一） http://blog.upsuper.org/opengl-small-test-1/ http://blog.upsuper.org/opengl-small-test-1/#comments Thu, 19 Feb 2009 13:17:10 +0000 upsuper http://blog.upsuper.org/?p=686 test1今天突然心血来潮想看看 OpenGL。找了个 OpenGL 的教程，看起来不错。不过这个教程着实吓了我一跳，第一篇的代码就超过了300行！先来一个效果图~

我参考的教程有：
OpenGL教程之新手上路
OpenGL教程之第一个多边形
OpenGL教程之着色
OpenGL教程之旋转
OpenGL教程之向3D进军

然后写了段小程序（不过大部分代码是直接抄的……而且我一点也不觉得小……398行……）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398

#include <windows.h>
#include <glgl.h>
#include <glglu.h>
#include <glglaux.h>
 
HGLRC hRC = NULL;
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;
 
bool keys[256];
bool active = true;
bool fullscreen = true;
 
GLfloat rtri;
GLfloat rquad;
 
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{
	if (height == 0)
		height = 1;
	glViewport(0, 0, width, height);
 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
 
	gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.1f, 100.0f);
 
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}
 
int InitGL(GLvoid)
{
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL);
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	return true;
}
 
int DrawGLScene(GLvoid)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glLoadIdentity();
	glTranslatef(-1.5f, 0.0f, -6.0f);
	glRotatef(rtri, 0.0f, 1.0f, 0.0f);
	glBegin(GL_TRIANGLES);
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 0.0f,  1.0f,  0.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f, 1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
	glEnd();
 
	glBegin(GL_QUADS);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
	glEnd();
 
	glLoadIdentity();
	glTranslatef(1.5f, 0.0f, -7.0f);
	glRotatef(rquad, 1.0f, 0.0f, 0.0f);
	glBegin(GL_QUADS);
		glColor3f(0.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
 
		glColor3f(1.0f, 0.5f, 0.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
 
		glColor3f(1.0f, 0.0f, 0.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 1.0f, 0.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
 
		glColor3f(0.0f, 0.0f, 1.0f);
		glVertex3f(-1.0f,  1.0f,  1.0f);
		glVertex3f(-1.0f,  1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f, -1.0f);
		glVertex3f(-1.0f, -1.0f,  1.0f);
 
		glColor3f(1.0f, 0.0f, 1.0f);
		glVertex3f( 1.0f,  1.0f, -1.0f);
		glVertex3f( 1.0f,  1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f,  1.0f);
		glVertex3f( 1.0f, -1.0f, -1.0f);
	glEnd();
 
	rtri += 0.2f;
	rquad -= 0.15f;
 
	return true;
}
 
GLvoid KillGLWindow(GLvoid)
{
	if (fullscreen)
	{
		ChangeDisplaySettings(NULL, 0);
		ShowCursor(true);
	}
 
	if (hRC)
	{
		if (! wglMakeCurrent(NULL, NULL))
			MessageBox(NULL, "Release Of DC And RC Failed.",
				"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		if (! wglDeleteContext(hRC))
			MessageBox(NULL, "Release Rendering Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hRC = NULL;
	}
 
	if (hDC && ! ReleaseDC(hWnd, hDC))
	{
		MessageBox(NULL, "Release Device Context Failed.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hDC = NULL;
	}
 
	if (hWnd && ! DestroyWindow(hWnd))
	{
		MessageBox(NULL, "Could Not Release hWnd.",
			"SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
		hWnd = NULL;
	}
}
 
bool CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint PixelFormat;
	WNDCLASS wc;
	DWORD dwExStyle;
	DWORD dwStyle;
 
	RECT WindowRect;
	WindowRect.left = (long)0;
	WindowRect.right = (long)width;
	WindowRect.top = (long)0;
	WindowRect.bottom = (long)height;
 
	fullscreen = fullscreenflag;
 
	hInstance = GetModuleHandle(NULL);
	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc = (WNDPROC) WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = NULL;
	wc.lpszClassName = "OpenGL";
 
	if (! RegisterClass(&wc))
	{
		MessageBox(NULL, "Failed To Register The Windows Class.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
		dmScreenSettings.dmSize = sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth = width;
		dmScreenSettings.dmPelsHeight = height;
		dmScreenSettings.dmBitsPerPel = bits;
		dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
 
		if (ChangeDisplaySettings(&dmScreenSettings, 
			CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		{
			if (MessageBox(NULL, 
				"The Requested Fullscreen Mode Is Not Supported By Your Video Card. Use Windowed Mode Instead?",
				"OpenGL", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
			{
				fullscreen = false;
			}
			else
			{
				MessageBox(NULL, "Program Will Now Close.",
					"ERROR", MB_OK | MB_ICONSTOP);
				return false;
			}
		}
	}
 
	if (fullscreen)
	{
		dwExStyle = WS_EX_APPWINDOW;
		dwStyle = WS_POPUP;
		ShowCursor(false);
	}
	else
	{
		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		dwStyle = WS_OVERLAPPEDWINDOW;
	}
	AdjustWindowRectEx(&WindowRect, dwStyle, false, dwExStyle);
 
	if (! (hWnd = CreateWindowEx(dwExStyle, "OpenGL", title,
		WS_CLIPSIBLINGS | WS_CLIPCHILDREN | dwStyle, 0, 0,
		WindowRect.right - WindowRect.left,
		WindowRect.bottom - WindowRect.top,
		NULL, NULL, hInstance, NULL)))
	{
		KillGLWindow();
		MessageBox(NULL, "Window Creation Error.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	static PIXELFORMATDESCRIPTOR pfd = 
	{
		sizeof(PIXELFORMATDESCRIPTOR), 1,
		PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
		PFD_TYPE_RGBA, bits, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		16, 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
	};
 
	if (! (hDC = GetDC(hWnd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Device Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (PixelFormat = ChoosePixelFormat(hDC, &pfd)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Find A Suitable PixelFormat.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! SetPixelFormat(hDC, PixelFormat, &pfd))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! (hRC = wglCreateContext(hDC)))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Create A GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	if (! wglMakeCurrent(hDC, hRC))
	{
		KillGLWindow();
		MessageBox(NULL, "Can't Activate The GL Rendering Context.",
			"ERROR", MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	ShowWindow(hWnd, SW_SHOW);
	SetForegroundWindow(hWnd);
	SetFocus(hWnd);
	ReSizeGLScene(width, height);
 
	if (! InitGL())
	{
		KillGLWindow();
		MessageBox(NULL, "Initialization Failed.", "ERROR",
			MB_OK | MB_ICONEXCLAMATION);
		return false;
	}
 
	return true;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_ACTIVATE:
		active = ! HIWORD(wParam);
		return 0;
	case WM_SYSCOMMAND:
		switch (wParam)
		{
		case SC_SCREENSAVE: 
		case SC_MONITORPOWER:
			return 0;
		}
		break;
	case WM_CLOSE:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
		keys[wParam] = true;
		return 0;
	case WM_KEYUP:
		keys[wParam] = false;
		return 0;
	case WM_SIZE:
		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		return 0;
	}
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	bool done = false;
 
	fullscreen = (MessageBox(NULL, 
		"Would You Like To Run In Fullscreen Mode?",
		"Start Fullscreen?", MB_YESNO | MB_ICONQUESTION) == IDYES);
	if (! CreateGLWindow("OpenGL Test", 640, 480, 16, fullscreen))
		return 0;
 
	while (! done)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				done = true;
			else
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
		else
		{
			if (active)
			{
				if (keys[VK_ESCAPE])
					done = true;
				else
				{
					DrawGLScene();
					SwapBuffers(hDC);
				}
			}
		}
	}
 
	KillGLWindow();
	return (msg.wParam);
}
]]> http://blog.upsuper.org/opengl-small-test-1/feed/ 0