自学教程：C++ subdivide函数代码示例

/* and draw the resulting triangles */void subdivide(GLfloat v1[3], GLfloat v2[3], GLfloat v3[3], int depth){  GLfloat v12[3], v23[3], v31[3];  int i;  if (depth == 0) {    glBegin(GL_TRIANGLES);      glNormal3fv(v1);   glVertex3fv(v1);            glNormal3fv(v2);   glVertex3fv(v2);            glNormal3fv(v3);   glVertex3fv(v3);          glEnd();     return;  }  /* calculate midpoints of each side */  for (i = 0; i < 3; i++) {    v12[i] = (v1[i]+v2[i])/2.0;    v23[i] = (v2[i]+v3[i])/2.0;    v31[i] = (v3[i]+v1[i])/2.0;  }  /* extrude midpoints to lie on unit sphere */  normalize(v12);  normalize(v23);  normalize(v31);  /* recursively subdivide new triangles */  subdivide(v1 , v12, v31, depth-1);  subdivide(v2 , v23, v12, depth-1);  subdivide(v3 , v31, v23, depth-1);  subdivide(v12, v23, v31, depth-1);}

void subdivide(std::vector<V>& vertices, std::vector<uint32_t>& indices, const vec3& p1, const vec3& p2, const vec3& p3, int level){    if (level > 0)    {        vec3 m1 = p1 + p2;        vec3 m2 = p2 + p3;        vec3 m3 = p3 + p1;        m1.normalize();        m2.normalize();        m3.normalize();        subdivide(vertices, indices, p1, m1, m3, level - 1);        subdivide(vertices, indices, m1, p2, m2, level - 1);        subdivide(vertices, indices, m2, m3, m1, level - 1);        subdivide(vertices, indices, m3, m2, p3, level - 1);    }    else    {        V v;        v.pos = p1;        vertices.push_back(v);        v.pos = p2;        vertices.push_back(v);        v.pos = p3;        vertices.push_back(v);        uint32_t start = indices.size();        indices.push_back(start);        indices.push_back(start + 1);        indices.push_back(start + 2);    }}

static void subdivide(apiflt *base, int xres, int yres, apiflt wx, apiflt wy,                  int x1, int y1, int x2, int y2) {  long x,y;  if (((x2 - x1) < 2) && ((y2 - y1) < 2)) { return; }  x=(x1 + x2) / 2;  y=(y1 + y2) / 2;  adjust(base, xres, yres, wx, wy, x1, y1, x, y1, x2, y1);  adjust(base, xres, yres, wx, wy, x2, y1, x2, y, x2, y2);  adjust(base, xres, yres, wx, wy, x1, y2, x, y2, x2, y2);  adjust(base, xres, yres, wx, wy, x1, y1, x1, y, x1, y2);   if (base[x + xres*y]==0.0) {    base[x + (xres * y)]=(base[x1 + xres*y1] + base[x2 + xres*y1] +                          base[x2 + xres*y2] + base[x1 + xres*y2]   )/4.0;  }   subdivide(base, xres, yres, wx, wy, x1, y1 ,x ,y);  subdivide(base, xres, yres, wx, wy, x, y1, x2, y);  subdivide(base, xres, yres, wx, wy, x, y, x2, y2);  subdivide(base, xres, yres, wx, wy, x1, y, x, y2);}

void OpenGL3DSphereRenderer::subdivide( const Eigen::Matrix<GLfloat,3,1>& v1, const Eigen::Matrix<GLfloat,3,1>& v2, const Eigen::Matrix<GLfloat,3,1>& v3, unsigned& current_vertex, const unsigned depth ){  // If we hit the lowest level of recursion  if( depth == 0 )  {    // Save the current triangle    saveTriangleInMem( v1, v2, v3, current_vertex );    return;  }  // New vertices lie on the midpoint of the three edges of the larger triangle  Eigen::Matrix<GLfloat,3,1> v12{ 0.5 * ( v1 + v2 ) };  Eigen::Matrix<GLfloat,3,1> v23{ 0.5 * ( v2 + v3 ) };  Eigen::Matrix<GLfloat,3,1> v31{ 0.5 * ( v3 + v1 ) };  // Ensure that the new vertices are on the surface of the sphere  v12 = v12.normalized();  v23 = v23.normalized();  v31 = v31.normalized();  // This triangle is divided into four children  subdivide( v1, v12, v31, current_vertex, depth - 1 );  subdivide( v2, v23, v12, current_vertex, depth - 1 );  subdivide( v3, v31, v23, current_vertex, depth - 1 );  subdivide( v12, v23, v31, current_vertex, depth - 1 );}

void subdivide(GLfloat u1[2], GLfloat u2[2], GLfloat u3[2],	       GLfloat cutoff, int depth,	       GLfloat(*curv) (GLfloat[2]),	       void (*surf) (GLfloat[2], GLfloat *, GLfloat *, GLfloat *)    ){    GLfloat v1[3], v2[3], v3[3];    GLfloat n1[3], n2[3], n3[3];    GLfloat t1[2], t2[2], t3[2];    GLfloat u12[2], u23[2], u31[2];    GLint i;    if (depth == 0 || ((*curv) (u1) < cutoff &&		       (*curv) (u2) < cutoff && (*curv) (u3) < cutoff)) {	(*surf) (u1, v1, n1, t1);	(*surf) (u2, v2, n2, t2);	(*surf) (u3, v3, n3, t3);	return;    }    for (i = 0; i < 2; i++) {	u12[i] = (u1[i] + u2[i]) / 2.0;	u23[i] = (u2[i] + u3[i]) / 2.0;	u31[i] = (u3[i] + u1[i]) / 2.0;    }    subdivide(u1, u12, u31, cutoff, depth - 1, curv, surf);    subdivide(u2, u23, u12, cutoff, depth - 1, curv, surf);    subdivide(u3, u31, u23, cutoff, depth - 1, curv, surf);    subdivide(u12, u23, u31, cutoff, depth - 1, curv, surf);}

GeodesicHemisphereMesh::GeodesicHemisphereMesh(unsigned level){    unsigned nv = (level + 1) * (level + 1) * 2;        unsigned nf = level * level * 2 * 2;        createVertices(nv);	createIndices(nf * 3);	Vector3F * p = vertices();		unsigned * idx = indices();		unsigned currentidx = 0;	unsigned currentver = 0;		Vector3F a(0.f, 1.f, 0.f);	Vector3F b(-1.f, 0.001f, 0.f);	Vector3F c(0.f, 0.001f, 1.f);	Vector3F d(1.f, 0.001f, 0.f);	Vector3F e(0.f, 0.001f, -1.f);		subdivide(level, currentver, currentidx, p, idx, a, b, c, d);	subdivide(level, currentver, currentidx, p, idx, a, d, e, b);    printf("vertices count: %d/n", currentver);    printf("indices count: %d/n", currentidx);	}

 static void subdivide (     GLfloat point0[3],      GLfloat point1[3],      GLfloat point2[3],      int level ) {     int coord;     GLfloat midpoint[3][3];          /* Don't subdivide any further; just draw the triangle */     if (level==0) {         glColor3fv(point0);         glVertex3fv(point0);         glColor3fv(point1);         glVertex3fv(point1);         glColor3fv(point2);         glVertex3fv(point2);         return;     }      /* Calculate a midpoint on each edge of the triangle */     for(coord = 0; coord<3; coord++) {         midpoint[0][coord] = (point0[coord] + point1[coord])*0.5;         midpoint[1][coord] = (point1[coord] + point2[coord])*0.5;         midpoint[2][coord] = (point2[coord] + point0[coord])*0.5;     }      /* Subdivide each triangle into three more */    /*     .      */     level--;                                         /*    /X/     */     subdivide(point0,midpoint[0],midpoint[2],level); /*   /xxx/    */     subdivide(point1,midpoint[1],midpoint[0],level); /*  /X/ /X/   */     subdivide(point2,midpoint[2],midpoint[1],level); /* /XXXVXXX/  */ }

/* ---------------------------------------------------------- */void subdivide(GLfloat v1[2], GLfloat v2[2],GLfloat v3[2], int depth){ 	int i;	GLfloat v12[2], v23[2], v31[2]; 		if (!depth) 	{		GLfloat P0[3],P1[3],P2[3],N0[3],N1[3],N2[3];		getPointOnTorus(P0,N0,v1[0],v1[1]);glNormal3fv(N0);glVertex3fv(P0);		getPointOnTorus(P1,N1,v2[0],v2[1]);glNormal3fv(N1);glVertex3fv(P1);		getPointOnTorus(P2,N2,v3[0],v3[1]);glNormal3fv(N2);glVertex3fv(P2);	}	else   	{		for (i = 0; i < 2; i++) 		{			v12[i] = (v1[i]+v2[i])/2.0f;			v23[i] = (v2[i]+v3[i])/2.0f;			v31[i] = (v3[i]+v1[i])/2.0f;				}		subdivide(v1 ,v12,v31 ,depth-1);		subdivide(v31,v12,v23 ,depth-1);		subdivide(v23,v12,v2  ,depth-1);		subdivide(v31,v23,v3  ,depth-1); 	}}

void TSphere::subdivide(const GLfloat inA[3], const GLfloat inB[3],    const GLfloat inC[3], size_t inDepth){    if (!inDepth)    {        addTriangle(inA, inB, inC);        return;    }        GLfloat ab[3];    GLfloat bc[3];    GLfloat ca[3];        for (size_t i = 0; i < 3; ++i)    {        ab[i] = (inA[i] + inB[i]) / 2.0f;        bc[i] = (inB[i] + inC[i]) / 2.0f;        ca[i] = (inC[i] + inA[i]) / 2.0f;    }        normalize(ab);    normalize(bc);    normalize(ca);        subdivide(inA, ab, ca, inDepth - 1);    subdivide(inB, bc, ab, inDepth - 1);    subdivide(inC, ca, bc, inDepth - 1);    subdivide(ab, bc, ca, inDepth - 1);}

/* ---------------------------------------------------------- */void subdivide(GLfloat v1[2], GLfloat v2[2],GLfloat v3[2], int depth){ 	int i;	GLfloat v12[2], v23[2], v31[2]; 		if (!depth) 	{		GLfloat P0[3],P1[3],P2[3],t0,t1,t2;		getPoint(P0,&t0,v1[0],v1[1]);glTexCoord1f(t0);glVertex3fv(P0);		getPoint(P1,&t1,v2[0],v2[1]);glTexCoord1f(t1);glVertex3fv(P1);		getPoint(P2,&t2,v3[0],v3[1]);glTexCoord1f(t2);glVertex3fv(P2);	}	else   	{		for (i = 0; i < 2; i++) 		{			v12[i] = (v1[i]+v2[i])/2.0f;			v23[i] = (v2[i]+v3[i])/2.0f;			v31[i] = (v3[i]+v1[i])/2.0f;				}		subdivide(v1 ,v12,v31 ,depth-1);		subdivide(v31,v12,v23 ,depth-1);		subdivide(v23,v12,v2  ,depth-1);		subdivide(v31,v23,v3  ,depth-1); 	}}

/* and draw the resulting triangles */void subdivide(GLfloat u1[2], GLfloat u2[2], GLfloat u3[2], float cutoff, int depth){   GLfloat v1[3], v2[3], v3[3], n1[3], n2[3], n3[3];   GLfloat u12[2], u23[2], u31[2];   int i;   if(depth == MAXDEPTH || (curv(u1) < cutoff && curv(u2) < cutoff && curv(u3) < cutoff)){    surf(u1,v1,n1);    surf(u2,v2,n2);    surf(u3,v3,n3);    glBegin(GL_POLYGON);      glNormal3fv(n1);       glVertex3fv(v1);      //glNormal3fv(n2);       glVertex3fv(v2);      //glNormal3fv(n3);      glVertex3fv(v3);    glEnd();    return;   }    for(i=0;i<2;i++){    u12[i]=(u1[i]+u2[i])/2.0;    u23[i]=(u2[i]+u3[i])/2.0;    u31[i]=(u1[i]+u3[i])/2.0;   }   subdivide(u1,u12,u31,cutoff,depth+1);   subdivide(u2,u23,u12,cutoff,depth+1);   subdivide(u3,u31,u23,cutoff,depth+1);   subdivide(u12,u23,u31,cutoff,depth+1);}

static voidsubdivide(glb_data *d,          const GLfloat * v1, GLuint vi1,	  const GLfloat * v2, GLuint vi2,	  const GLfloat * v3, GLuint vi3,	  int depth){	int         i;	if (depth == 0) {		save_triangle(d, vi1, vi2, vi3);	} else {		GLuint      vi12, vi23, vi31;		GLfloat     v12[3], v23[3], v31[3];		for (i = 0; i < 3; ++i) {			v12[i] = v1[i] + v2[i];			v23[i] = v2[i] + v3[i];			v31[i] = v3[i] + v1[i];		}		normalize(v12);		vi12 = save_vertex(d, v12);		normalize(v23);		vi23 = save_vertex(d, v23);		normalize(v31);		vi31 = save_vertex(d, v31);		subdivide(d, v1, vi1, v12, vi12, v31, vi31, depth - 1);		subdivide(d, v2, vi2, v23, vi23, v12, vi12, depth - 1);		subdivide(d, v3, vi3, v31, vi31, v23, vi23, depth - 1);		subdivide(d, v12, vi12, v23, vi23, v31, vi31, depth - 1);	}}

void subdivide(char ar[], int low, int high, int level){	if (level == 0)		return;	int mid = (high + low) / 2;	ar[mid] = '|';	subdivide(ar, low, mid, level-1);	subdivide(ar, mid, high, level-1);}

void subdivide(char ar[],int head,int foot,int level){	int mid;	if(level==0) return;	mid=(head+foot)/2;	ar[mid]='|';	subdivide(ar,head,mid,level-1);	subdivide(ar,mid,foot,level-1);}

static void subdivide(BVItem* items, int nitems, int imin, int imax, int& curNode, dtBVNode* nodes){	int inum = imax - imin;	int icur = curNode;		dtBVNode& node = nodes[curNode++];		if (inum == 1)	{		// Leaf		node.bmin[0] = items[imin].bmin[0];		node.bmin[1] = items[imin].bmin[1];		node.bmin[2] = items[imin].bmin[2];				node.bmax[0] = items[imin].bmax[0];		node.bmax[1] = items[imin].bmax[1];		node.bmax[2] = items[imin].bmax[2];				node.i = items[imin].i;	}	else	{		// Split		calcExtends(items, nitems, imin, imax, node.bmin, node.bmax);				int	axis = longestAxis(node.bmax[0] - node.bmin[0],							   node.bmax[1] - node.bmin[1],							   node.bmax[2] - node.bmin[2]);				if (axis == 0)		{			// Sort along x-axis			qsort(items+imin, inum, sizeof(BVItem), compareItemX);		}		else if (axis == 1)		{			// Sort along y-axis			qsort(items+imin, inum, sizeof(BVItem), compareItemY);		}		else		{			// Sort along z-axis			qsort(items+imin, inum, sizeof(BVItem), compareItemZ);		}				int isplit = imin+inum/2;				// Left		subdivide(items, nitems, imin, isplit, curNode, nodes);		// Right		subdivide(items, nitems, isplit, imax, curNode, nodes);				int iescape = curNode - icur;		// Negative index means escape.		node.i = -iescape;	}}

void subdivide(BezierRow const& G, int N, std::vector<glm::vec3> &points){	if (N==0){		points.push_back(G[1]);		points.push_back(G[4]);	}	else{		subdivide(G*DLB, N - 1, points);		subdivide(G*DRB, N - 1, points);	}}

void BezierPath::const_iterator::flatten_adaptive(BezierPath::vertices& v,						  Coord flat) const{  unsigned int subdivisions;  //vector2d<double> d1, d2, d3;  v.push_back(control_[0]);  switch(type()) {  case move:    return;  case line:  case close:    v.push_back(control_[1]);    return;  case parabolic:{    BezierPath::Point p1,p2;    p1.x() = (2*control_[1].x() + control_[0].x())/3.;    p1.y() = (2*control_[1].y() + control_[0].y())/3.;    p2.x() = (2*control_[1].x() + control_[2].x())/3.;    p2.y() = (2*control_[1].y() + control_[2].y())/3.;    subdivisions = compute_subdivisions(control_[0], p1,					p2, control_[2],					flat);    v.reserve(v.size()+(1 << subdivisions));    subdivide(v, 	      control_[0], p1,	      p2, control_[2],	      flat*flat);    return;  }  case cubic:    subdivisions = compute_subdivisions(control_[0], control_[1],					control_[2], control_[3],					flat);    v.reserve(v.size()+(1 << subdivisions));    subdivide(v, 	      control_[0], control_[1],	      control_[2], control_[3],	      flat*flat);    return;  default:    assert(type() == line ||	   type() == move ||	   type() == parabolic ||	   type() == cubic);    return;  }}

static void subdivide( vector<q3_vertex> &verts,int level,int index,int step ){	if( !level ){		q3_vertex t1,t2;		average( verts[index],verts[index+step],&t1 );		average( verts[index+step],verts[index+step*2],&t2 );		average( t1,t2,&verts[index+step] );		return;	}	average( verts[index],verts[index+step],&verts[index+step/2] );	average( verts[index+step],verts[index+step*2],&verts[index+step+step/2] );	average( verts[index+step/2],verts[index+step+step/2],&verts[index+step] );	subdivide( verts,level-1,index,step/2 );	subdivide( verts,level-1,index+step,step/2 );}

void BSPSector::subdivide(BSPSector* sector){    AABB aabbLeft, aabbRight;     sector->getBoundingBox()->divide( aabbLeft, aabbRight, AABB::maxPlane );    sector->_leftSubset  = new BSPSector( sector->_bsp, sector, aabbLeft, NULL );    sector->_rightSubset = new BSPSector( sector->_bsp, sector, aabbRight, NULL );    if( sector->getSectorLevel() < 3 )    {        subdivide( sector->_leftSubset );        subdivide( sector->_rightSubset );    }}

void SimplexSphereGenerator::subdivide(const D3DXVECTOR3 &v1, const D3DXVECTOR3 &v2, const D3DXVECTOR3 &v3, vector<D3DXVECTOR3> &sphere_points, const unsigned int depth) {	if (depth == 0) {		sphere_points.push_back(v1);		sphere_points.push_back(v2);		sphere_points.push_back(v3);		return;	}	D3DXVECTOR3 v12; D3DXVec3Normalize(&v12, &(v1 + v2));	D3DXVECTOR3 v23; D3DXVec3Normalize(&v23, &(v2 + v3));	D3DXVECTOR3 v31; D3DXVec3Normalize(&v31, &(v3 + v1));	subdivide(v1, v12, v31, sphere_points, depth - 1);	subdivide(v2, v23, v12, sphere_points, depth - 1);	subdivide(v3, v31, v23, sphere_points, depth - 1);	subdivide(v12, v23, v31, sphere_points, depth - 1);}

t_get	*subdivide(char *s, t_get *prev, char **bad_sintax){  size_t l;  t_get *link;  if (empty(s))    return (prev);  if (s[0] == '//' && prev)    if ((!S_IN(prev->word, "/"'|;<>()`")))      return (echappment(s, prev, bad_sintax, 0));  if ((link = xmalloc(sizeof(*prev))) == NULL)    return (NULL);  link->word = (void*)(link->next = NULL);  link->prev = prev;  if (prev)    prev->next = link;  s += hempty(s);  if (s[(link->inter = 0)] == '//')    return (echappment(s, link, bad_sintax, 1));  l = subdiv(s, bad_sintax);  if (*bad_sintax)    return (nullify_link(link, 0, 1));  if ((link->word = my_strndup(s, l)) == NULL)    return (nullify_link(link, 0, 1));  if (subdivide(s + my_strlen(link->word), link, bad_sintax) == NULL)    return (nullify_link(link, 1, 1));  return (link);}

bool rcCreateChunkyTriMesh(const float* verts, const int* tris, int ntris,						   int trisPerChunk, rcChunkyTriMesh* cm){	int nchunks = (ntris + trisPerChunk-1) / trisPerChunk;	cm->nodes = new rcChunkyTriMeshNode[nchunks*4];	if (!cm->nodes)		return false;			cm->tris = new int[ntris*3];	if (!cm->tris)		return false;			cm->ntris = ntris;	// Build tree	BoundsItem* items = new BoundsItem[ntris];	if (!items)		return false;	for (int i = 0; i < ntris; i++)	{		const int* t = &tris[i*3];		BoundsItem& it = items[i];		it.i = i;		// Calc triangle XZ bounds.		it.bmin[0] = it.bmax[0] = verts[t[0]*3+0];		it.bmin[1] = it.bmax[1] = verts[t[0]*3+2];		for (int j = 1; j < 3; ++j)		{			const float* v = &verts[t[j]*3];			if (v[0] < it.bmin[0]) it.bmin[0] = v[0]; 			if (v[2] < it.bmin[1]) it.bmin[1] = v[2]; 			if (v[0] > it.bmax[0]) it.bmax[0] = v[0]; 			if (v[2] > it.bmax[1]) it.bmax[1] = v[2]; 		}	}	int curTri = 0;	int curNode = 0;	subdivide(items, ntris, 0, ntris, trisPerChunk, curNode, cm->nodes, nchunks*4, curTri, cm->tris, tris);		delete [] items;		cm->nnodes = curNode;		// Calc max tris per node.	cm->maxTrisPerChunk = 0;	for (int i = 0; i < cm->nnodes; ++i)	{		rcChunkyTriMeshNode& node = cm->nodes[i];		const bool isLeaf = node.i >= 0;		if (!isLeaf) continue;		if (node.n > cm->maxTrisPerChunk)			cm->maxTrisPerChunk = node.n;	}	 	return true;}

TriangleGraph::TriangleGraph(int n):_size(20 * (int)pow(4.0,n)){	const float phi = 1 + sqrt(5.0) / 2;	_triangles = new Triangle[_size];	_triangles_new = new Triangle[_size];	int currentSize = 20;	Triangle* startTriangles = calculateStartTriangles();	normalize(startTriangles, currentSize);	link_triangles(startTriangles);	for(int i = 0; i < currentSize; i++){_triangles[i] = startTriangles[i]; }		for(int tes = 0 ; tes <n; tes++)	{		for(int i = 0; i < currentSize; i++)		{			Triangle new_triangles [4];			subdivide(_triangles[i], new_triangles[0], new_triangles[1], new_triangles[2], new_triangles[3]);			for(int ii = 0; ii < 4; ii++)			{				_triangles_new[new_triangles[ii].id] = new_triangles[ii];			}		}		currentSize = currentSize * 4;		for(int i = 0; i < currentSize; i++){_triangles[i] = _triangles_new[i]; }		normalize(_triangles, currentSize);	}}

void WaterQuadTree::draw(const Camera &camera, double delta_time) {	if (!setup_done()) { return; }	if (!camera.intersects_box(_patch->get_center(), _patch->get_extents())) {		remove_children();		return;	}	// Get LOD metric to see if we should draw child quads or just draw this one	double rho = compute_level_metric(camera, distance_to_patch(camera, _patch->get_center()));	if (rho >= 0.0 || _level > _deepest_level) {		_patch->draw(camera, delta_time);		remove_children();	}	else {		// If we already have created the children then just draw them		if (_has_children) {			if (_northwest->setup_done() && _northeast->setup_done() &&				_southwest->setup_done() && _southeast->setup_done()) {				_northwest->draw(camera, delta_time);				_northeast->draw(camera, delta_time);				_southwest->draw(camera, delta_time);				_southeast->draw(camera, delta_time);			}			else {				// Draw this tile until all children is setup				_patch->draw(camera, delta_time);			}		}		else { // Else create children and draw this tile			subdivide();			_patch->draw(camera, delta_time);		}	}}

int insert(node* currentNode, body* pBody, int level) {  // Return false if body does not belong in this node.  if(!checkBounds(pBody, currentNode)) {    return 0;  }  // Insert body into node  if(currentNode->nodeBody == NULL) {    currentNode->nodeBody = pBody;    return 1;  }  // Prevent adding body to same location (Skip Parents)  if((!currentNode->isParent) & ((currentNode->nodeBody->pX == pBody->pX) & (currentNode->nodeBody->pY == pBody->pY))) {    return 0;  }  // Subdivide node  if(currentNode->northWest == NULL) {    subdivide(currentNode);    currentNode->isParent = 1;    insert(currentNode, currentNode->nodeBody, level+1);    // TODO: Add body averaging    currentNode->nodeBody = newBody(1,  -1,  -1,  0,  0);  }  // Put point into subtree  if(insert(currentNode->northWest, pBody, level+1)) return 1;  if(insert(currentNode->northEast, pBody, level+1)) return 1;  if(insert(currentNode->southEast, pBody, level+1)) return 1;  if(insert(currentNode->southWest, pBody, level+1)) return 1;  // Return false if point cannot be inserted.  return 0;}

void BezierPatchModel::update(){	glBindVertexArray(0);	glBindBuffer(GL_ARRAY_BUFFER, 0);		glDeleteBuffers(BUFFER_COUNT, buffers);	glDeleteVertexArrays(1, &vao);        for (std::vector<BezierPatch>::const_iterator patch = patches.begin();            patch != patches.end(); ++patch) {        subdivide(* patch, level);    }    glGenVertexArrays(1, &vao);    glBindVertexArray(vao);    glGenBuffers(BUFFER_COUNT, buffers);    glBindBuffer(GL_ARRAY_BUFFER, buffers[VERTEX_BUFFER]);    glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * vertices.size(),            &vertices[0], GL_STATIC_DRAW);    glBindBuffer(GL_ARRAY_BUFFER, buffers[NORMAL_BUFFER]);    glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec3) * normals.size(),            &normals[0], GL_STATIC_DRAW);    glBindVertexArray(0);    num_vertices = vertices.size();    vertices.clear();    normals.clear();}

LidarProcessOctree::Node* LidarProcessOctree::nextNodePrefix(LidarProcessOctree::Node* node)	{	/* Check if the node is an interior node: */	if(node->childrenOffset!=0)		{		/* Subdivide the node if necessary: */		if(node->children==0)			subdivide(*node);				/* Go to the node's first child: */		return &node->children[0];		}	else		{		while(node->parent!=0)			{			/* Find the node's index among its parent's children: */			int childIndex;			for(childIndex=0;childIndex<8&&node!=&node->parent->children[childIndex];++childIndex)				;						/* Return the node's next sibling if there is one: */			if(childIndex+1<8)				return &node->parent->children[childIndex+1];						/* Try the node's parent: */			node=node->parent;			}				/* The root doesn't have siblings; we're done here: */		return 0;		}	}

void rt_landscape(void * tex, int m, int n,               	vector ctr, apiflt wx, apiflt wy) {  int totalsize, x, y;  apiflt * field;   totalsize=m*n;  srand(totalsize);  field=(apiflt *) malloc(totalsize*sizeof(apiflt));  for (y=0; y<n; y++) {    for (x=0; x<m; x++) {       field[x + y*m]=0.0;    }  }  field[0 + 0]=1.0 + (rand() % 100)/100.0;  field[m - 1]=1.0 + (rand() % 100)/100.0;  field[0     + m*(n - 1)]=1.0 + (rand() % 100)/100.0;  field[m - 1 + m*(n - 1)]=1.0 + (rand() % 100)/100.0;  subdivide(field, m, n, wx, wy, 0, 0, m-1, n-1);  rt_sheightfield(tex, ctr, m, n, field, wx, wy);  free(field);}

void insert_source(node_t *node, source_t *source) {    node_t *quadrant;        // Check if the MAX has been reached    if (node->contents.length == MAX)        subdivide(node);        // A node in the tree will be filled with either content or sub    // quadrants. Check to see whether subquads exist.    if (node->q1 != NULL) {        if (source->x >= node->xmid) {            if (source->y >= node->ymid)                quadrant = node->q1;            else                quadrant = node->q4;        } else {            if (source->y >= node->ymid)                quadrant = node->q2;            else                quadrant = node->q3;        }        insert_source(quadrant, source);    } else {            // If no subquads exist add source to the list in contents element         // Use push() to prepend the source on the list.        push(&node->contents, source);    }}