/// <summary>
/// A data structure to hold a list of CollisionMesh objects with quick access geometry data. 
/// </summary>
public class CollisionModel : AccessibleModel
{
	/// <summary>
	/// number of divisions to apply to the octree
	/// </summary>
	private uint maxTreeDivisions;
	/// <summary>
	/// the threshold limit for leaf node volume
	/// </summary>
	private float minTreeNodeVolume;

	/// <summary>
	/// constructor with a default XNA model located in the specified file location
	/// </summary>
	/// <param name="newName">a name for the object</param>
	/// <param name="newGame">the game object</param>
	/// <param name="newLeafNodeVolume"></param>
	/// <param name="maxTreeDivisions">the maximum number of times to subdivide the octree</param>
	/// <param name="newModelFile">the path to a model file to load into this accessible model</param>
	public CollisionModel(string newName, TwelveCylinderGame newGame,
				float newLeafNodeVolume, uint newMaxTreeDivisions, string newModelFile)
		: base(newName, newGame, newModelFile)
	{
		minTreeNodeVolume = newLeafNodeVolume;
		maxTreeDivisions = newMaxTreeDivisions;
		createCollisionTrees(minTreeNodeVolume);
	}

	/// <summary>
	/// Creates an array of meshes from the (XNA class) input Model.
	/// This method overrides its parent's method and creates CollisionMesh
	/// objects instead of AccessibleMesh objects.
	/// </summary>
	/// <param name="newModel">the XNA Model object</param>
	protected override void initFromModel(Model newModel)
	{
		meshCount = newModel.Meshes.Count;
		triangleCount = 0;
		vertexCount = 0;

		mMeshes = new CollisionMesh[meshCount];
		for (int i = 0; i < meshCount; i++)
		{
			//create collision mesh objects which make up this collision model...
			mMeshes[i] = new CollisionMesh(newModel.Meshes[i].Name, curGame, newModel.Meshes[i]);
			this.addChild(mMeshes[i]); //loads world position data

			//sum number of primitives
			triangleCount += mMeshes[i].FaceCount;
			vertexCount += mMeshes[i].VertexCount;
		}
	}

	/// <summary>
	/// create collision tree definitions for each mesh in this model
	/// </summary>
	protected virtual void createCollisionTrees(float newLeafNodeVolume)
	{
		foreach(CollisionMesh mesh in mMeshes)
			mesh.createCollisionTree(maxTreeDivisions, newLeafNodeVolume);
	}

	//encapsulators omitted

	/// <summary>
	/// gets the collision mesh at the specified index
	/// </summary>
	/// <param name="index">a mesh index</param>
	/// <returns>the collision mesh</returns>
	public CollisionMesh getCollisionMesh(int index)
	{
		return (mMeshes[index] as CollisionMesh);
	}

	/// <summary>
	/// find the first (if any) collision between the
	/// specified moving box and this CollisionModel
	/// </summary>
	/// <param name="boxData">input description of the moving box to test for collisions</param>
	/// <param name="collisionDistance">output distance from box's starting position to collision point</param>
	/// <param name="collisionPosition">output position at which the collision occured</param>
	/// <param name="collisionNormal">output normal of the surface at the collision point</param>
	/// <returns>returns true if an intersection occured</returns>
	public bool BoxIntersect(MovingBoxData boxData, out float collisionDistance,
				out Vector3 collisionPosition, out Vector3 collisionNormal)
	{
		collisionDistance = boxData.OffsetLength;
		collisionPosition = boxData.WorldEnd;
		collisionNormal = Vector3.Zero;

		if (mMeshes == null || mMeshes.Length == 0)
			return false;

		bool collision = false;
		float distance;
		Vector3 position;
		Vector3 normal;

		//find first collision occurence
		foreach (CollisionMesh mesh in mMeshes)
		{
			if (mesh.Tree.BoxIntersect(boxData, out distance, out position, out normal))
			{
				//intersection found
				if (distance < collisionDistance)
				{
					//current intersect distance
					//is less than any previous
					collisionDistance = distance; //output distance
					collisionPosition = position; //output position
					collisionNormal = normal;     //output normal at collision point
					collision = true;
				}
			}
		}
		return collision;
	}

	//point intersection omitted...
}