鬼の领地

#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;
}