OctTree help!

struct TRIANGLE
{
	Vector3 p0, p1, p2;
	DWORD material;
};

class cOctTreeNode
{
public:
	Vector3              m_Min;
	Vector3              m_Max;
	std::vector<TRIANGLE*>   m_pTriangles;
	DWORD                    m_NumTriangles;
	cOctTreeNode*            m_pChildren[8];
	DWORD                    m_Depth;

					         cOctTreeNode();
	void                     AddTriangle(TRIANGLE* triangle);
	bool                     CheckTriangle(TRIANGLE* triangle);
	void                     Shutdown();
};

cOctTreeNode::cOctTreeNode()
{
	m_Min = m_Max = Vector3(0.0f, 0.0f, 0.0f);
	m_pChildren[0] = m_pChildren[1] = m_pChildren[2] = m_pChildren[3] = m_pChildren[4] = m_pChildren[5] = m_pChildren[6] = m_pChildren[7] = NULL;
	m_NumTriangles = 0;
	m_Depth = -1;
}

void cOctTreeNode::AddTriangle(TRIANGLE* tri)
{
	static DWORD MaxTrianglesPerNode = 200;
	for(int i=0; i < 8; i++)
	{
		if(m_pChildren != NULL && m_pChildren->CheckTriangle(tri))
		{
			m_pChildren->AddTriangle(tri);
			printf("Adding to child %lu (depth %lu)\n", i, m_Depth+1);
			return;
		}
	}

	m_pTriangles.push_back(tri);
	++m_NumTriangles;

	if(m_NumTriangles >= MaxTrianglesPerNode && m_pChildren[0] == NULL)
	{
		float Mx = m_Max.x;
		float My = m_Max.y;
		float Mz = m_Max.z;
		float mx = m_Min.x;
		float my = m_Min.y;
		float mz = m_Min.z;
		float hx = (m_Max.x + m_Min.x)/2.0f;
		float hy = (m_Max.y + m_Min.y)/2.0f;
		float hz = (m_Max.z + m_Min.z)/2.0f;

		m_pChildren[0] = new cOctTreeNode;
		m_pChildren[0]->m_Min = Vector3(mx, hy, hz);
		m_pChildren[0]->m_Max = Vector3(hx, My, Mz);

		m_pChildren[1] = new cOctTreeNode;
		m_pChildren[1]->m_Min = Vector3(hx, hy, hz);
		m_pChildren[1]->m_Max = Vector3(Mx, My, Mz);

		m_pChildren[2] = new cOctTreeNode;
		m_pChildren[2]->m_Min = Vector3(mx, hy, mz);
		m_pChildren[2]->m_Max = Vector3(hx, My, hz);

		m_pChildren[3] = new cOctTreeNode;
		m_pChildren[3]->m_Min = Vector3(hx, hy, mz);
		m_pChildren[3]->m_Max = Vector3(Mx, My, hz);

		m_pChildren[4] = new cOctTreeNode;
		m_pChildren[4]->m_Min = Vector3(mx, my, hz);
		m_pChildren[4]->m_Max = Vector3(hx, hy, Mz);

		m_pChildren[5] = new cOctTreeNode;
		m_pChildren[5]->m_Min = Vector3(hx, my, hz);
		m_pChildren[5]->m_Max = Vector3(Mx, hy, Mz);

		m_pChildren[6] = new cOctTreeNode;
		m_pChildren[6]->m_Min = Vector3(mx, my, mz);
		m_pChildren[6]->m_Max = Vector3(hx, hy, hz);

		m_pChildren[7] = new cOctTreeNode;
		m_pChildren[7]->m_Min = Vector3(hx, my, mz);
		m_pChildren[7]->m_Max = Vector3(Mx, hy, hz);
		
		m_pChildren[0]->m_Depth = m_pChildren[1]->m_Depth = m_pChildren[2]->m_Depth = m_pChildren[3]->m_Depth = m_pChildren[4]->m_Depth = m_pChildren[5]->m_Depth = m_pChildren[6]->m_Depth = m_pChildren[7]->m_Depth = m_Depth + 1;

		vector<TRIANGLE*> temp = m_pTriangles;
		m_pTriangles.erase(m_pTriangles.begin(), m_pTriangles.end());
		m_NumTriangles = 0;
		for(DWORD i=0; i < temp.size(); i++)
		{
			AddTriangle(temp);
		}
	}
}

bool cOctTreeNode::CheckTriangle(TRIANGLE* tri)
{
	if(((m_Min.x < tri->p0.x && tri->p0.x < m_Max.x) && (m_Min.y < tri->p0.y && tri->p0.y < m_Max.y) && (m_Min.z < tri->p0.z && tri->p0.z < m_Max.z)) &&
	   ((m_Min.x < tri->p1.x && tri->p1.x < m_Max.x) && (m_Min.y < tri->p1.y && tri->p1.y < m_Max.y) && (m_Min.z < tri->p1.z && tri->p1.z < m_Max.z)) &&
	   ((m_Min.x < tri->p2.x && tri->p2.x < m_Max.x) && (m_Min.y < tri->p2.y && tri->p2.y < m_Max.y) && (m_Min.z < tri->p2.z && tri->p2.z < m_Max.z)))
	   return true;
	else
		return false;
}

void cOctTreeNode::Shutdown()
{
	for(DWORD i=0; i < 8; i++)
	{
		if(m_pChildren != NULL)
		{
			m_pChildren->Shutdown();
			delete m_pChildren;
			m_pChildren = NULL;
		}
	}
}