[OpenGL] 场景管理四叉树demo

        所谓的四叉树场景管理就是先对场景进行预处理，用四叉树存储所有物体，运行中通过四叉树查询，只渲染当前区域的物体，以提高帧率，减少GPU的负担。

        整个demo，效果已经基本出来了，但在精度上有点问题，可能是因为邻域选的比较小，导致有时候视线里会突然冒出来一个物体。下图中红点代表人物。

       俯视：

        

        透视

包括三个类：

 

        场景管理类

        四叉树类

        物体类

 

物体类包含了物体的性质，目前以正方体代替物体，只包含边长，颜色和位置。实际中扩展的版本应该包含：

 

        顶点坐标

        下标索引

        纹理索引

        颜色数据

        ……

 

 

四叉树类包括以下几个部分：

 

性质：

        最小的地图砖块边长

        四叉树层数

        四叉树头节点

 

功能：

        插入节点（初始化）

        查找节点

 

场景管理包括以下几个部分：

 

场景创建：

 

        设计的四叉树比较简单，创建的方式用的是按层次建树，而不是递归方式，不允许一个物体同时处在两个区域，所以前期需要用特殊的地图编辑器（按理来说应该是一个桌面小软件，编辑好之后可以存成一个四叉树文件）。

        在这里，为了方便，写了一个简单的自动场景生成，详情见函数randBuildTree(),以迭代的方式一层层随机生成方块的位置。

 

数据结构：

 

std::set<Object*> set;//集合

std::list<Object*> list[MAX];//链表

 

        1. 物体的集合，包含了所有当前帧需要渲染的物体。（渲染内容）

        2. 当前位置邻域包含的物体，是一个链表的数组，数组的每个元素对应邻域的一块，每一块对应一个链表，包含了这一块的所有物体。（预备内容）

 

       之所以要把做一个邻域的链表，是因为不同的list查询的结果可能有重复的，所以最终渲染的时候要把物体放到集合中，保证唯一性。

         

    如果邻域选取3x3，那么数组大小为9，编号如上。

 

场景更新

 

           因为四叉树有很多层，不同层对应着不同尺度的物体，我们首先需要定义主角所在的层数，然后以这个层数为基础来搜索邻域。

         每一帧都调用一次更新函数，首先检查位置是否发生变化，可能发生的变化是：向右移动一格，向左移动一格，向上移动一格，向下移动一格。如果发生了，那么执行这样的操作：

 

 

 

 

        （1） 在预备链表中，移除红色区域的物体

        （2） 在预备链表中，加入黄色区域的物体

        （3） 更新显示的集合

         加入和移除是通过【四叉树的查找】来实现的。

         盗用了一下别人的图来显示一下这个过程：

         

代码

object.h

#pragma once
struct vec {
	float x;
	float y;
	float z;
};
class Object
{
public:
	float radius;
	float center_x;
	float center_y;
	vec color;
	Object(float _radius, float cx, float cy);
	void draw();
};

sceneManage.h

#pragma once
#include "tree.h"
#include "object.h"
#include <set>
#include <list>

class sceneManage
{
public:
	enum {
		MAX = 9,
		SIZE = 3,
		LAYER = 6,
		CURLAYER = 5,
		BLOCKSIZE = 1,
		LENGTH = 64,
	};
private:

	bool *isUsed;
	quadtree* tree;
	std::set<Object*> set;
	std::list<Object*> list[MAX];
	std::list<Object*> alllist;
	int cur_x;
	int cur_y;
	int n;
	int offset;
	void removeSet(int i, int j, int k);
	void removeSet(int i);
	void updateSet(int i, int j, int k);
	void updateSet(int i);
	void randBuildTree();
	void printMap();
public:

	std::list<Object*>& getAllObj();
	void init(float x, float y);
	std::set<Object*>& getObj();
	void moveTo(float x, float y);
	sceneManage();
};

tree.h

#pragma once
#include <list>
#include "object.h"

struct Box
{
	float xmin;
	float xmax;
	float ymin;
	float ymax;
	Box();
	Box(float _xmin, float _xmax, float _ymin, float _ymax);
};

struct treeNode {
	Box box;
	treeNode* child[4];
	std::list<Object*> List;
	bool hasChild;
	treeNode();
	void setBox(treeNode* parent, int i);
};

class quadtree
{
private:
	float blockSize;
	int layer;
	treeNode* head;
	std::list<Object*> allObj;
public:
	void print();
	std::list<Object*> findAll();
	std::list<Object*> find(float x, float y, int layer = -1);
	quadtree(float size, int l);
	void add(int layer, int x, int y, Object* obj);
};

object.cpp

#include "object.h"
#include <stdlib.h>
#include <stdio.h>
#include "gl/glut.h"

Object::Object(float r, float cx, float cy) :radius(r), center_x(cx), center_y(cy)
{
	color.x = (1.0*(rand() % 100) / 100);
	color.y = (1.0*(rand() % 100) / 100);
	color.z = (1.0*(rand() % 100) / 100);
	//printf("radius = %f \n", radius);
}

void Object::draw()
{
	glPushMatrix();
	glColor3f(color.x, color.y, color.z);
	//printf("%f %f %f\n", center_x - radius / 2, radius / 2, center_y - radius / 2);
	glTranslatef(center_x - radius / 2, radius / 2, center_y - radius / 2);
	glutSolidCube(radius);
	glPopMatrix();
}

sceneManage.cpp

#include "sceneManage.h"
#include <fstream>
#include <time.h>

sceneManage::sceneManage()
{
	srand(time(nullptr));
	n = pow(2.0, LAYER);
	offset = 2 * BLOCKSIZE;
	tree = new quadtree(BLOCKSIZE, LAYER);
	// block大小为1, 层数为6
	randBuildTree();
}

void sceneManage::init(float x, float y)
{
	list[0] = tree->find(x - offset, y + offset, LAYER);
	list[1] = tree->find(x - offset, y, LAYER);
	list[2] = tree->find(x - offset, y - offset, LAYER);
	list[3] = tree->find(x, y - offset, LAYER);
	list[4] = tree->find(x + offset, y - offset, LAYER);
	list[5] = tree->find(x + offset, y, LAYER);
	list[6] = tree->find(x + offset, y + offset, LAYER);
	list[7] = tree->find(x, y + offset, LAYER);
}

void sceneManage::printMap()
{
	std::ofstream out("map.txt");
	for (int i = 0; i < 64; i++) {
		for (int j = 0; j < 64; j++) {
			if (isUsed[64 * i + j]) {
				out << "X ";
			}
			else {
				out << ". ";
			}
		}
		out << "\n";
	}
	out << "\n";
}

void sceneManage::randBuildTree()
{
	isUsed = new bool[4096];
	for (int i = 0; i < 4096; i++) {
		isUsed[i] = false;
	}
	int num[6];
	num[0] = 0; // 4
	num[1] = 0; // 16
	num[2] = 2; // 64
	num[3] = 20; // 256
	num[4] = 40; // 1024
	num[5] = 200; // 4096

	int size = 64;
	int half = size >> 1;
	int nsize = 2;
	for (int k = 0; k < 6; k++) {
		//printf("size = %d half=%d\n", size,half);
		for (int i = 0; i < num[k]; i++) {
			int r;
			do {
				r = rand() % 4096;
			} while (isUsed[r]);
			int r1 = (r / 64) % nsize;//x
			int r2 = (r % 64) % nsize;//y
			float h = 1.0 * half / 2;
			//printf("h = %.1f\n", h);
			//printf("r1 = %f r2 = %f\n", -32 + h + r2 *half, -32 + h + r1 *half);
			//printf("h = %.0f r = %.0f cx = %.0f cy = %.0f ", h, half, -h + r2 *half, -h + r1 *half);
			Object* obj = new Object(half, -LENGTH / 2 * BLOCKSIZE + h + r2 *half, -LENGTH / 2 * BLOCKSIZE + h + r1 *half);
			tree->add(k + 1, r1, r2, obj);

			for (int k1 = r1 * half; k1 < (r1 + 1) * half; k1++) {
				for (int k2 = r2 * half; k2 < (r2 + 1) * half; k2++) {
					isUsed[k1 * 64 + k2] = true;
				}
			}
		}
		size = half;
		half = size >> 1;
		nsize = nsize << 1;
	}
	//tree->print();
	printMap();
}

void sceneManage::removeSet(int i)
{
	std::list<Object*>::iterator it;
	for (it = list[i].begin(); it != list[i].end(); it++) {
		set.erase(*it);
	}
}

void sceneManage::removeSet(int i, int j, int k)
{
	std::list<Object*>::iterator it;
	for (it = list[i].begin(); it != list[i].end(); it++) {
		set.erase(*it);
	}
	for (it = list[j].begin(); it != list[j].end(); it++) {
		set.erase(*it);
	}
	for (it = list[k].begin(); it != list[k].end(); it++) {
		set.erase(*it);
	}
}

void sceneManage::updateSet(int i)
{
	std::list<Object*>::iterator it;
	for (it = list[i].begin(); it != list[i].end(); it++) {
		set.insert(*it);
	}
}

void sceneManage::updateSet(int i, int j, int k)
{
	std::list<Object*>::iterator it;
	for (it = list[i].begin(); it != list[i].end(); it++) {
		set.insert(*it);
	}
	for (it = list[j].begin(); it != list[j].end(); it++) {
		set.insert(*it);
	}
	for (it = list[k].begin(); it != list[k].end(); it++) {
		set.insert(*it);
	}
}

std::list<Object*>& sceneManage::getAllObj()
{
	return tree->findAll();
}

std::set<Object*>& sceneManage::getObj()
{
	return set;
}

void sceneManage::moveTo(float x, float y)
{
	x /= BLOCKSIZE;
	y /= BLOCKSIZE;
	if (x == cur_x && y == cur_y) {
		return;
	}
	if (x == cur_x + 1) {
		printf("move right\n");
		removeSet(0, 1, 2);
		list[0] = tree->find(x - offset, y + offset, CURLAYER);
		list[1] = tree->find(x - offset, y, CURLAYER);
		list[2] = tree->find(x - offset, y - offset, CURLAYER);
		updateSet(0, 1, 2);
	}
	else if (y == cur_y + 1) {
		printf("move front\n");
		removeSet(2, 3, 4);
		list[2] = tree->find(x - offset, y - offset, CURLAYER);
		list[3] = tree->find(x, y - offset, CURLAYER);
		list[4] = tree->find(x + offset, y - offset, CURLAYER);
		updateSet(2, 3, 4);
	}
	else if (x == cur_x - 1) {
		printf("move left\n");
		removeSet(4, 5, 6);
		list[4] = tree->find(x + offset, y - offset, CURLAYER);
		list[5] = tree->find(x + offset, y, CURLAYER);
		list[6] = tree->find(x + offset, y + offset, CURLAYER);
		updateSet(4, 5, 6);
	}
	else if (y == cur_y - 1) {
		printf("move back\n");
		removeSet(0, 7, 6);
		list[0] = tree->find(x - offset, y + offset, CURLAYER);
		list[7] = tree->find(x, y + offset, CURLAYER);
		list[6] = tree->find(x + offset, y + offset, CURLAYER);
		updateSet(0, 7, 6);
	}
	list[8] = tree->find(x, y, CURLAYER);
	removeSet(8);
	updateSet(8);
	cur_x = x;
	cur_y = y;
}

tree.cpp

#include "tree.h"
#include <math.h>
#include <queue>
//#include <QTextStream>
//static QTextStream cout(stdout, QIODevice::WriteOnly);


Box::Box() {}
Box::Box(float _xmin, float _xmax, float _ymin, float _ymax) :
xmin(_xmin), xmax(_xmax), ymin(_ymin), ymax(_ymax)
{

}



treeNode::treeNode()
{
	for (int i = 0; i < 4; i++) {
		child[i] = nullptr;
	}
	hasChild = false;
}

void treeNode::setBox(treeNode* parent, int i)
{
	switch (i) {
	case 0: {
				box.xmax = parent->box.xmin + (parent->box.xmax - parent->box.xmin) / 2;
				box.xmin = parent->box.xmin;
				box.ymax = parent->box.ymax;
				box.ymin = parent->box.ymin + (parent->box.ymax - parent->box.ymin) / 2;
				break;
	}
	case 1: {
				box.xmax = parent->box.xmin + (parent->box.xmax - parent->box.xmin) / 2;
				box.xmin = parent->box.xmin;
				box.ymax = parent->box.ymin + (parent->box.ymax - parent->box.ymin) / 2;
				box.ymin = parent->box.ymin;
				break;
	}
	case 2: {
				box.xmax = parent->box.xmax;
				box.xmin = parent->box.xmin + (parent->box.xmax - parent->box.xmin) / 2;
				box.ymax = parent->box.ymin + (parent->box.ymax - parent->box.ymin) / 2;
				box.ymin = parent->box.ymin;
				break;
	}
	case 3: {
				box.xmax = parent->box.xmax;
				box.xmin = parent->box.xmin + (parent->box.xmax - parent->box.xmin) / 2;
				box.ymax = parent->box.ymax;
				box.ymin = parent->box.ymin + (parent->box.ymax - parent->box.ymin) / 2;
				break;
	}
	}
}

std::list<Object*> quadtree::findAll()
{
	return allObj;
}

quadtree::quadtree(float size, int l)
{
	int n = pow(2, l - 1);
	blockSize = size;
	layer = l;
	head = new treeNode();
	head->box.xmin = -n * size;
	head->box.xmax = n * size;
	head->box.ymin = -n * size;
	head->box.ymax = n * size;
}

std::list<Object*> quadtree::find(float x, float y, int layer)
{
	treeNode* node = head;
	treeNode* parent = nullptr;
	int count = 0;
	while (node != nullptr) {
		//	printf("count = %d\n", count);
		if (count == layer) {
			break;
		}
		int index;
		//	printf("%f %f\n", node->box.xmax - node->box.xmin, node->box.ymax - node->box.ymin);
		int i = 2 * (x + head->box.xmax) / (node->box.xmax - node->box.xmin);
		i = i % 2;
		int j = 2 * (y + head->box.ymax) / (node->box.ymax - node->box.ymin);
		j = j % 2;
		if (i == 0 && j == 0) {
			index = 1;
		}
		else if (i == 0 && j == 1) {
			index = 0;
		}
		else if (i == 1 && j == 0) {
			index = 2;
		}
		else if (i == 1 && j == 1) {
			index = 3;
		}
		parent = node;
		node = node->child[index];
		//	printf("index = %d\n", index);
		count++;
	}
	return parent->List;
}

void quadtree::add(int layer, int x, int y, Object* obj)
{
	allObj.push_back(obj);
	int n = pow(2, layer);
	int *index = new int[layer];
	int half = n >> 1;
	for (int i = layer - 1; i >= 0; i--) {
		if (x % 2 == 1) {
			if (y % 2 == 1) {
				index[i] = 2;
			}
			else {
				index[i] = 1;
			}
		}
		else {
			if (y % 2 == 1) {
				index[i] = 3;
			}
			else {
				index[i] = 0;
			}
		}
		x >>= 1;
		y >>= 1;
	}
	treeNode* node = head;
	for (int i = 0; i < layer - 1; i++) {
		if (!node->child[index[i]]) {
			node->child[index[i]] = new treeNode();
			node->child[index[i]]->setBox(node, index[i]);
		}
		if (node != head)node->List.push_back(obj);
		node->hasChild = true;
		node = node->child[index[i]];
	}
	treeNode* childNode = new treeNode();
	childNode->List.push_back(obj);
	if (node != head)node->List.push_back(obj);
	node->child[index[layer - 1]] = childNode;
	childNode->setBox(node, index[layer - 1]);
	node->hasChild = true;
}

void quadtree::print()
{
	treeNode* tmp;
	std::queue<treeNode*>q;
	q.push(head);
	int cur = 1;
	int curnum = 1;
	int nextnum = 0;
	while (!q.empty()) {
		tmp = q.front();
		q.pop();
		if (tmp->hasChild) {
			curnum--;
			//cout << "[";
			printf("[");
			for (int i = 0; i < 4; i++) {
				if (tmp->child[i]) {
					std::list<Object*>::iterator it;
					for (it = tmp->child[i]->List.begin(); it != tmp->child[i]->List.end(); it++) {
						printf("{%.0f %.0f %.0f}", (*it)->radius, (*it)->center_x, (*it)->center_y);
					}
					q.push(tmp->child[i]);
					nextnum++;
				}
				else printf("_");
				if (i != 3)printf(",");

			}
			printf("]");
		}
		if (curnum == 0) {
			printf("\n");
			cur++;
			curnum = nextnum;
			nextnum = 0;
		}
	}
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS        
//simd
#include <stdlib.h>         
#include <time.h>             
#include "sceneManage.h"
#include"gl/glut.h" 

float cx = 0, cz = 0;
float center[] = { 0, 0, 0 };
float eye[] = { 0, 100,3};
float tx, ty = 0, ax, ay = 0, mx, my, zoom = 0;
bool isLine = false;
bool isDown = false;
bool isDrawAll = false;
sceneManage* scene;
float step = 1.0f;

void getFPS()
{
	static int frame = 0, time, timebase = 0;
	static char buffer[256]; //字符串缓冲区  

	frame++;
	time = glutGet(GLUT_ELAPSED_TIME);
	//返回两次调用glutGet(GLUT_ELAPSED_TIME)的时间间隔,单位为毫秒  
	if (time - timebase > 1000) { //时间间隔差大于1000ms时  
		sprintf(buffer, "FPS:%4.2f\n position(%.2f,%.2f)",
			frame*1000.0 / (time - timebase),cx,cz); //写入buffer中  
		//printf("%f\n", frame*1000.0 / (time - timebase));
		timebase = time; //上一次的时间间隔  
		frame = 0;
	}
	

	char *c;
	glColor3f(0,0,0);
	glDisable(GL_DEPTH_TEST);     // 禁止深度测试  
	glMatrixMode(GL_PROJECTION);  // 选择投影矩阵  
	glPushMatrix();               // 保存原矩阵  
	glLoadIdentity();             // 装入单位矩阵  
	glOrtho(0, 480, 0, 480, -1, 1);    // 位置正投影  
	glMatrixMode(GL_MODELVIEW);   // 选择Modelview矩阵  
	glPushMatrix();               // 保存原矩阵  
	glLoadIdentity();             // 装入单位矩阵  
	glRasterPos2f(10, 10);
	for (c = buffer; *c != '\0'; c++) {
		glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *c); //绘制字符  
	}
	glMatrixMode(GL_PROJECTION);  // 选择投影矩阵  
	glPopMatrix();                // 重置为原保存矩阵  
	glMatrixMode(GL_MODELVIEW);   // 选择Modelview矩阵  
	glPopMatrix();                // 重置为原保存矩阵  
	glEnable(GL_DEPTH_TEST);      // 开启深度测试  
}

void reshape(int width, int height)
{
	if (height == 0) height = 1;
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	float whRatio = (GLfloat)width / (GLfloat)height;
	gluPerspective(45, whRatio, 1, 500);
	glMatrixMode(GL_MODELVIEW);
}

void idle()
{
	glutPostRedisplay();
}

void init(void)
{
	//glClearColor(1.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_DEPTH_TEST);
	glColor4f(1.0, 1.0, 1.0, 1.0f);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
	glEnable(GL_COLOR_MATERIAL);
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	scene = new sceneManage();
	scene->init(cx, -cz);
}

void redraw()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(1, 1, 1, 1);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	gluLookAt(eye[0], eye[1], eye[2], center[0], center[1], center[2], 0, 1, 0);

	
	if (isLine)glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glPushMatrix();
	glColor3f(0.3f, 0, 0);
	glTranslatef(cx, 0.1f, cz);
	glutSolidSphere(0.3f, 20, 10);
	glPopMatrix();

	/*
	glPushMatrix();
	glTranslatef(cx, 0.1, cz);
	glColor3f(1,0, 0);
	glRotatef(90, 1, 0, 0);
	glRectd(-4, -4, 4, 4);
	glPopMatrix();*/

	glPushMatrix();
	glColor3f(0.2, 0.2, 0.2);
	glRotatef(90, 1, 0, 0);
	for (int i = 0; i < 64; i++){
		for (int j = 0; j < 64; j++){
			glPushMatrix();
			glTranslatef(-scene->LENGTH / 2 * scene->BLOCKSIZE + i*scene->BLOCKSIZE, -scene->LENGTH / 2 * scene->BLOCKSIZE + j*scene->BLOCKSIZE,0);
			glRectd(0, 0,scene->BLOCKSIZE, scene->BLOCKSIZE);
			glPopMatrix();
		}
	}
	//glRectd(-scene->LENGTH / 2 * scene->BLOCKSIZE, -scene->LENGTH / 2 * scene->BLOCKSIZE, scene->LENGTH / 2 * scene->BLOCKSIZE, scene->LENGTH / 2 * scene->BLOCKSIZE);
	glPopMatrix();

	if (isDrawAll) {
		std::list<Object*>::iterator it;
		std::list<Object*> list = scene->getAllObj();
		printf("size = %d\n", list.size());
		for (it = list.begin(); it != list.end(); it++) {
			(*it)->draw();
		}
	}
	else {
		scene->moveTo(cx, -cz);
		glColor3f(0, 0, 0);
		glPushMatrix();
		//glutSolidCube(3);
		std::set<Object*> set = scene->getObj();
		std::set<Object*>::iterator it;
		int count = 0;
		for (it = set.begin(); it != set.end(); it++) {
			count++;
			(*it)->draw();
		}
		//if(count!=0)printf("count = %d\n",count);
		glPopMatrix();
	}
	getFPS();
	glutSwapBuffers();
}

void myMouse(int button, int state, int x, int y)
{
	if (button == GLUT_LEFT_BUTTON) {
		if (state == GLUT_DOWN) {
			isDown = true;
			mx = x;
			my = y;
		}
		else if (state == GLUT_UP) {
			isDown = false;
		}
	}
	glutPostRedisplay();
}

void mouseMotion(int x, int y)
{
	if (isDown) {
		ax += 1.0f*(y - my) / 10.0f;
		ay += 1.0f*(x - mx) / 10.0f;
		mx = x;
		my = y;
	}
	glutPostRedisplay();
}

void myKeyboard(unsigned char key, int x, int y)
{
	//printf("%d  \n",key);
	switch (key) {
	case 'a': { //左移 
				  cx -= step;
				  eye[0] -= step;
				  center[0] -= step;
				  if (cx < -31) {
					  cx = -31;
					  eye[0] = -31;
					  center[0] = -31;
				  }
				  break;
	}
	case 'd': { //右移    
				  cx += step;
				  eye[0] += step;
				  center[0] += step;
				  if (cx > 31) {
					  cx = 31;
					  eye[0] = 31;
					  center[0] = 31;
				  }
				  break;
	}
	case 'w': { //上移    
				  cz -= step;
				  eye[2] -= step;
				  center[2] -= step;
				  if (cz < -31) {
					  cz = -31;
					  eye[2] = -31;
					  center[2] = -31;
				  }
				  break;
	}
	case 's': { //下移    
				  cz += step;
				  eye[2] += step;
				  center[2] += step;
				  if (cz > 31) {
					  cz = 31;
					  eye[2] = 31;
					  center[2] = 31;
				  }
				  break;
	}
	case 'z': { //后移    
				  zoom += 1;
				  break;
	}
	case 'c': { //前移    
				  zoom -= 1;
				  break;
	}
	case 'p': {
				  // 切换绘制模式  
				  if (isLine) {
					  isLine = false;
				  }
				  else isLine = true;
				  break;
	}
	case 'm': {
				  if (isDrawAll) {
					  isDrawAll = false;
				  }
				  else isDrawAll = true;
	}
	}
	//glutPostRedisplay();
}

int main(int argc, char *argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
	glutInitWindowSize(800, 600);
	int windowHandle = glutCreateWindow("Simple GLUT App");
	glutDisplayFunc(redraw);
	glutReshapeFunc(reshape);
	glutMouseFunc(myMouse);
	glutMotionFunc(mouseMotion);
	glutKeyboardFunc(myKeyboard);
	glutIdleFunc(idle);
	init();
	glutMainLoop();
	//system("pause");
	return 0;
}