+Unity Runtime codeHEADmaster

1 files changed, 798 insertions, 0 deletions

diff --git a/Runtime/Terrain/TerrainRenderer.cpp b/Runtime/Terrain/TerrainRenderer.cpp
new file mode 100644
index 0000000..8ab2e0f
--- /dev/null
+++ b/Runtime/Terrain/TerrainRenderer.cpp
@@ -0,0 +1,798 @@
+#include "UnityPrefix.h"
+#include "TerrainRenderer.h"
+
+#if ENABLE_TERRAIN
+
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+#	include "Runtime/GfxDevice/GfxDevice.h"
+#	include "Runtime/Terrain/QuadTreeNodeRenderer.h"
+#else
+#	include "Runtime/Camera/IntermediateRenderer.h"
+#endif
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Graphics/LightmapSettings.h"
+#include "Runtime/Camera/Camera.h"
+
+TerrainRenderer::TerrainRenderer (SInt32 instanceID, PPtr<TerrainData> terrainData, const Vector3f &position, int lightmapIndex)
+#if UNITY_EDITOR
+:	m_InstanceID(instanceID)
+#endif
+{
+	m_Scale = terrainData->GetHeightmap().GetScale();
+	m_Levels = terrainData->GetHeightmap().GetMipLevels();
+	m_TerrainData = terrainData;
+	m_Position = position;
+	m_LeftNeighbor = NULL;
+	m_RightNeighbor = NULL;
+	m_BottomNeighbor = NULL;
+	m_TopNeighbor = NULL;
+
+	m_SplatMaterials = new SplatMaterials (m_TerrainData);
+
+	m_LightmapIndex = lightmapIndex;
+	
+	RebuildNodes ();
+}
+
+TerrainRenderer::~TerrainRenderer ()
+{
+	delete m_SplatMaterials;
+
+	for (std::vector<QuadTreeNode>::iterator it = m_Quadtree.begin(), itEnd = m_Quadtree.end(); it != itEnd; ++it)
+	{
+		RemoveMesh(*it);
+	}
+
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+	for (std::list<VBO*>::iterator it = m_FreeVBOPool.begin(), itEnd = m_FreeVBOPool.end(); it != itEnd; ++it)
+	{
+		GetGfxDevice().DeleteVBO(*it);
+	}
+#endif
+}
+
+void TerrainRenderer::SetNeighbors (TerrainRenderer *left, TerrainRenderer *top, TerrainRenderer *right, TerrainRenderer *bottom)
+{
+	m_TopNeighbor = top;
+	m_RightNeighbor = right;
+	m_BottomNeighbor = bottom;
+	m_LeftNeighbor = left;
+}
+
+void TerrainRenderer::SetTerrainData(PPtr<TerrainData> value) 
+{
+	m_TerrainData = value;
+}
+
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+
+VBO* TerrainRenderer::CreateVBO()
+{
+	if (!m_FreeVBOPool.empty())
+	{
+		VBO* vbo = m_FreeVBOPool.back();
+		m_FreeVBOPool.pop_back();
+		return vbo;
+	}
+
+	// create new VBO
+	return GetGfxDevice().CreateVBO();
+}
+
+void TerrainRenderer::ReclaimVBO(VBO* vbo)
+{
+	AssertIf(vbo == NULL);
+	m_FreeVBOPool.push_back(vbo);
+}
+
+#endif
+		
+int TerrainRenderer::GetIndex (int x, int y, int level)
+{
+	int index = 0;
+	for (int i=0;i<level;i++)
+	{
+		int size = 1 << (m_Levels - i);
+		index += size * size;
+	}
+	
+	int width = 1 << (m_Levels - level);
+	index += width * y;
+	index += x;
+
+	Assert (index >= 0 && index < m_Quadtree.size());
+
+	return index;
+}
+	
+QuadTreeNode *TerrainRenderer::GetNode (int x, int y, int level)
+{
+	if (level < 0 || level > m_Levels)
+		return NULL;
+	int size = 1 << (m_Levels - level);
+
+	if (x < 0 || x >= size || y < 0 || y >= size)
+	{
+		// Left
+		if (x == -1 && m_LeftNeighbor != NULL)
+			return m_LeftNeighbor->GetNode (size - 1, y, level);
+		
+		// right
+		if (x == size && m_RightNeighbor != NULL)
+			return m_RightNeighbor->GetNode (0, y, level);
+
+		// top
+		if (y == size && m_TopNeighbor != NULL)
+			return m_TopNeighbor->GetNode (x, 0, level);
+
+		// bottom
+		if (y == -1 && m_BottomNeighbor != NULL)
+			return m_BottomNeighbor->GetNode (x, size-1, level);
+
+		return NULL;
+	}
+	
+	return &m_Quadtree[GetIndex(x, y, level)];
+}
+
+QuadTreeNode *TerrainRenderer::GetNodeAndRenderer (int x, int y, int level, TerrainRenderer *&renderer)
+{
+	if (level < 0 || level > m_Levels)
+	{
+		renderer = NULL;
+		return NULL;
+	}
+	int size = 1 << (m_Levels - level);
+
+	if (x < 0 || x >= size || y < 0 || y >= size)
+	{
+		// Left
+		if (x == -1 && m_LeftNeighbor != NULL)
+		{
+			renderer = m_LeftNeighbor;
+			return m_LeftNeighbor->GetNode (size - 1, y, level);
+		}
+
+		// right
+		if (x == size && m_RightNeighbor != NULL)
+		{
+			renderer = m_RightNeighbor;
+			return m_RightNeighbor->GetNode (0, y, level);
+		}
+
+		// top
+		if (y == size && m_TopNeighbor != NULL)
+		{
+			renderer = m_TopNeighbor;
+			return m_TopNeighbor->GetNode (x, 0, level);
+		}
+		
+		// bottom
+		if (y == -1 && m_BottomNeighbor != NULL)
+		{
+			renderer = m_BottomNeighbor;
+			return m_BottomNeighbor->GetNode (x, size-1, level);
+		}
+		
+		renderer = NULL;
+		return NULL;
+	}
+	
+	renderer = this;
+	return &m_Quadtree[GetIndex(x, y, level)];
+}
+
+int TerrainRenderer::GetPatchCountX (int level)
+{
+	return 1 << (m_Levels - level);
+}
+
+int TerrainRenderer::GetPatchCountY (int level)
+{
+	return 1 << (m_Levels - level);
+}
+
+void TerrainRenderer::RebuildNodes ()
+{
+	Heightmap &heightmap = m_TerrainData->GetHeightmap();
+	int totalSize = heightmap.GetTotalPatchCount();
+
+	m_Quadtree.resize(totalSize);
+	for (int level=0;level <= m_Levels;level++)
+	{
+		for (int y=0;y<GetPatchCountY(level);y++)
+		{
+			for (int x=0;x<GetPatchCountX(level);x++)
+			{
+				int index = GetIndex(x, y, level);
+				m_Quadtree[index].x = x;
+				m_Quadtree[index].y = y;
+				m_Quadtree[index].level = level;
+				m_Quadtree[index].maxHeightError = heightmap.GetMaximumHeightError(x, y, level);
+				m_Quadtree[index].bounds = heightmap.GetBounds(x, y, level);
+				m_Quadtree[index].bounds.GetCenter() += m_Position;
+			}
+		}
+	}
+}
+
+Vector3f TerrainRenderer::GetNodePosition (QuadTreeNode &node)
+{
+	Vector3f position = Vector3f::zero;
+	position += m_Position;
+	return position;
+}
+	
+int TerrainRenderer::CalculateEdgeMask (QuadTreeNode &node)
+{
+	//@TODO: Handle case where invisible (dont need to switch index buffers)
+	int mask = 0;
+	for (int i=kDirectionLeft;i<=kDirectionDown;i++)
+	{
+		QuadTreeNode *neighbor = FindNeighbor(node, i);
+		if (neighbor != NULL)
+		{
+			if (neighbor->visibility == kVisibilityDrawChild || neighbor->visibility == kVisibilityDrawSelf)
+				mask |= 1 << i;
+		}
+		else
+			mask |= 1 << i;
+	}
+	return mask;
+}
+	
+QuadTreeNode *TerrainRenderer::FindNeighbor (QuadTreeNode &node, int direction)
+{
+	if (direction == kDirectionUp)
+		return GetNode(node.x, node.y + 1, node.level);
+	else if (direction == kDirectionDown)
+		return GetNode(node.x, node.y - 1, node.level);
+	else if (direction == kDirectionLeft)
+		return GetNode(node.x - 1, node.y, node.level);
+	else
+		return GetNode(node.x + 1, node.y, node.level);
+}
+
+QuadTreeNode *TerrainRenderer::FindNeighborAndRenderer (QuadTreeNode &node, int direction, TerrainRenderer *&renderer)
+{
+	if (direction == kDirectionUp)
+		return GetNodeAndRenderer(node.x, node.y + 1, node.level, renderer);
+	else if (direction == kDirectionDown)
+		return GetNodeAndRenderer(node.x, node.y - 1, node.level, renderer);
+	else if (direction == kDirectionLeft)
+		return GetNodeAndRenderer(node.x - 1, node.y, node.level, renderer);
+	else
+		return GetNodeAndRenderer(node.x + 1, node.y, node.level, renderer);
+}
+	
+QuadTreeNode *TerrainRenderer::FindChild (QuadTreeNode &node, int direction)
+{
+	if (direction == kDirectionLeftUp)
+		return GetNode(node.x * 2, node.y * 2, node.level - 1);
+	else if (direction == kDirectionRightUp)
+		return GetNode(node.x * 2 + 1, node.y * 2, node.level - 1);
+	else if (direction == kDirectionLeftDown)
+		return GetNode(node.x * 2, node.y * 2 + 1, node.level - 1);
+	else
+		return GetNode(node.x * 2 + 1, node.y * 2 + 1, node.level - 1);
+}
+	
+QuadTreeNode *TerrainRenderer::FindParent (QuadTreeNode &node)
+{
+	return GetNode(node.x / 2, node.y / 2, node.level + 1);
+}
+	
+void TerrainRenderer::RenderStep1 (Camera *camera, int maxLodLevel, float tau, float splatDistance)
+{
+	// clamp LOD level to valid values
+	maxLodLevel = clamp(maxLodLevel, 0, m_Levels);
+
+	float nearClip = camera->GetNear();
+	float vTop = nearClip * tanf( Deg2Rad( camera->GetFov() / 2.0F )  );
+	float vres = camera->GetScreenViewportRect().height;
+	
+	float A = nearClip / fabs(vTop);
+	float T = 2 * tau / (float)vres;
+	float kC = A / T;
+
+	QuadTreeNode& root = GetRootNode();
+
+	m_CachedCameraPosition = camera-> QueryComponent(Transform)->GetPosition();
+	m_CachedMaxLodLevel = maxLodLevel;
+	m_CachedkC = kC;
+	m_CachedSqrSplatDistance = splatDistance * splatDistance;
+
+	RecursiveCalculateLod(root);
+}
+	
+void TerrainRenderer::RenderStep2 ()
+{
+	QuadTreeNode& root = GetRootNode();
+	
+	EnforceLodTransitions(root);
+}
+	
+void TerrainRenderer::RenderStep3 (Camera *camera, int layer, bool castShadows, Material* mat)
+{
+	QuadTreeNode &root = GetRootNode();
+	
+	m_CurrentLayer = layer;
+	m_CurrentCamera = camera;
+	m_CastShadows = castShadows;
+
+	// Get Splat materials
+	m_CurrentMaterials = m_SplatMaterials->GetMaterials (mat, m_CurrentMaterialCount);
+	m_CurrentBaseMaterial = m_SplatMaterials->GetSplatBaseMaterial (mat);
+
+	RecursiveRenderMeshes(root, m_TerrainData->GetHeightmap());
+}
+
+	
+void TerrainRenderer::CleanupMeshes ()
+{
+	for (std::vector<QuadTreeNode>::iterator node=m_Quadtree.begin();node != m_Quadtree.end(); node++)
+	{
+		if (node->visibility == kVisibilityDrawSelf)
+			RemoveMesh(*node);
+		node->visibility = kVisibilityLoddedAway;
+		node->oldVisibility = kVisibilityLoddedAway;
+	}
+}
+	
+void TerrainRenderer::ReloadAll () {
+	Cleanup ();
+
+	m_Scale = m_TerrainData->GetHeightmap().GetScale();
+	m_Levels = m_TerrainData->GetHeightmap().GetMipLevels();
+
+	
+	delete m_SplatMaterials;
+	m_SplatMaterials = new SplatMaterials (m_TerrainData);
+	
+	RebuildNodes ();
+}
+
+void TerrainRenderer::Cleanup () {
+	CleanupMeshes();
+	m_SplatMaterials->Cleanup ();
+}
+
+void TerrainRenderer::UnloadVBOFromGfxDevice ()
+{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+	// This will put all VBOs back into m_FreeVBOPool
+	for (std::vector<QuadTreeNode>::iterator node=m_Quadtree.begin();node != m_Quadtree.end(); node++)
+	{
+		RemoveMesh(*node);
+		node->updateIndices = true;
+		node->updateMesh = true;
+	}
+
+	for (std::list<VBO*>::iterator it = m_FreeVBOPool.begin(), itEnd = m_FreeVBOPool.end(); it != itEnd; ++it)
+	{
+		GetGfxDevice().DeleteVBO(*it);
+	}
+	m_FreeVBOPool.clear();
+#endif
+}
+
+void TerrainRenderer::ReloadVBOToGfxDevice ()
+{
+	// No need to do anything, since QuadTreeNodeRenderers will recreate themselves
+}
+	
+float TerrainRenderer::CalculateSqrDistance (Vector3f &rkPoint, AABB &rkBox)
+{
+	// compute coordinates of point in box coordinate system
+	Vector3f kClosest = rkPoint - rkBox.GetCenter();
+
+	// project test point onto box
+	float fSqrDistance = 0.0f;
+	float fDelta;
+	Vector3f& extents = rkBox.GetExtent();
+	
+	for (int i=0;i<3;i++)
+	{
+		if ( kClosest[i] < -extents[i] )
+		{
+			fDelta = kClosest[i] + extents[i];
+			fSqrDistance += fDelta * fDelta;
+			kClosest[i] = -extents[i];
+		}
+		else if ( kClosest[i] > extents[i] )
+		{
+			fDelta = kClosest[i] - extents[i];
+			fSqrDistance += fDelta * fDelta;
+			kClosest[i] = extents[i];
+		}
+	}
+
+	return fSqrDistance;
+}
+
+void TerrainRenderer::MarkChildVisibilityRecurse (QuadTreeNode &node, int newVisibility)
+{
+	if (node.level == 0)
+		return;
+		
+	for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+	{
+		QuadTreeNode* childNode = FindChild (node, i);
+		if (childNode->visibility != newVisibility)
+		{
+			childNode->visibility = newVisibility;
+			MarkChildVisibilityRecurse(*childNode, newVisibility);
+		}
+	}
+}
+
+void TerrainRenderer::ReloadPrecomputedError ()
+{
+	Heightmap &heightmap = m_TerrainData->GetHeightmap();
+	for (std::vector<QuadTreeNode>::iterator node=m_Quadtree.begin();node != m_Quadtree.end(); node++)
+		node->maxHeightError = heightmap.GetMaximumHeightError(node->x, node->y, node->level);
+}
+
+void TerrainRenderer::ReloadBounds ()
+{
+	Heightmap &heightmap = m_TerrainData->GetHeightmap();
+	for (std::vector<QuadTreeNode>::iterator node=m_Quadtree.begin();node != m_Quadtree.end(); node++)
+	{
+		node->bounds = heightmap.GetBounds(node->x, node->y, node->level);
+		node->bounds.GetCenter() += m_Position;
+	}
+}
+		
+void TerrainRenderer::RecursiveCalculateLod (QuadTreeNode &node)
+{
+	// Distance to bounding volume based
+	float distance = CalculateSqrDistance(m_CachedCameraPosition, node.bounds);
+
+	float D2 = m_CachedkC * node.maxHeightError;
+	D2 *= D2;
+
+	// Node has good enough lod, render it
+	if (distance > D2 || node.level == m_CachedMaxLodLevel)
+	{
+		node.visibility = kVisibilityDrawSelf;
+		node.useSplatmap = distance < m_CachedSqrSplatDistance;
+		MarkChildVisibilityRecurse(node, kVisibilityLoddedAway);
+	}
+	// Node needs subdivision
+	else
+	{
+		node.visibility = kVisibilityDrawChild;
+		
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode* childNode = FindChild (node, i);
+			RecursiveCalculateLod (*childNode);
+		}
+	}
+}
+
+void TerrainRenderer::ForceSplitParent (QuadTreeNode &node)
+{
+	QuadTreeNode* parent = FindParent(node);
+	Assert (parent != NULL);
+	if (parent->visibility == kVisibilityLoddedAway)
+		ForceSplitParent (*parent);
+
+	if (parent->visibility == kVisibilityDrawSelf)
+	{
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode* childNode = FindChild (*parent, i);
+			Assert (childNode != NULL);
+			
+			childNode->visibility = kVisibilityDrawSelf;
+			childNode->useSplatmap = CalculateSqrDistance(m_CachedCameraPosition, childNode->bounds) < m_CachedSqrSplatDistance;
+			
+			MarkChildVisibilityRecurse(*childNode, kVisibilityLoddedAway);
+		}
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode *childNode = FindChild (*parent, i);
+			Assert (childNode != NULL);
+
+			EnforceLodTransitions(*childNode);
+		}
+		parent->visibility = kVisibilityDrawChild;
+	}
+}
+
+// Go through all nodes that are being rendered
+// Check if the parent neighbor 
+void TerrainRenderer::EnforceLodTransitions (QuadTreeNode &node)
+{
+	if (node.visibility == kVisibilityLoddedAway)
+		return;
+
+	if (node.visibility == kVisibilityDrawSelf)
+	{
+		for (int i=kDirectionLeft;i<=kDirectionDown;i++)
+		{
+			TerrainRenderer *renderer;
+			
+			// If we have a neighbor, make sure it's either a root node that's completely LOD'd away
+			// or that it's at most one detail level away from us (i.e. that the neighbor's tree is split down at
+			// least to the level of the neighbor's parent).
+			QuadTreeNode *neighbor = FindNeighborAndRenderer (node, i, renderer);
+			if (neighbor != NULL && neighbor->visibility == kVisibilityLoddedAway && !renderer->IsRootNode (*neighbor))
+			{
+				QuadTreeNode *neighborParent = renderer->FindParent(*neighbor);
+				Assert (neighborParent != NULL);
+
+				if (neighborParent->visibility == kVisibilityLoddedAway)
+				{
+					renderer->ForceSplitParent(*neighborParent);
+				}
+			}
+		}
+	}
+	else
+	{
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode *childNode = FindChild (node, i);
+			Assert (childNode != NULL);
+
+			EnforceLodTransitions(*childNode);
+		}
+	}
+}
+
+void TerrainRenderer::RemoveMesh (QuadTreeNode &node)
+{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+	if (node.vbo != NULL)
+	{
+		ReclaimVBO(node.vbo);
+		node.vbo = NULL;
+		node.updateMesh = false;
+		node.updateIndices = false;
+	}
+#else
+	// Cleanup self
+	if(node.mesh)
+	{
+		DestroySingleObject (node.mesh);
+		node.mesh = NULL;
+	}
+#endif
+}
+	
+void TerrainRenderer::RecursiveRemoveMeshes (QuadTreeNode &node)
+{
+	if (node.oldVisibility == kVisibilityLoddedAway)
+		return;
+	
+	if (node.oldVisibility == kVisibilityDrawSelf)
+	{
+		RemoveMesh(node);
+	}
+	else if (node.oldVisibility == kVisibilityDrawChild)
+	{
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode* childNode = FindChild (node, i);
+			RecursiveRemoveMeshes(*childNode);
+		}
+	}
+
+	node.oldVisibility = kVisibilityLoddedAway;
+}
+
+void TerrainRenderer::RenderNode (QuadTreeNode &node)
+{
+	int layer = m_CurrentLayer;
+	Camera *camera = m_CurrentCamera;
+	Vector3f position = GetNodePosition(node);
+	
+	Matrix4x4f matrix;
+	matrix.SetTranslate( position );
+	bool castShadows = m_CastShadows;
+	
+	if (node.useSplatmap)
+	{
+		int count = m_CurrentMaterialCount;
+		for (int m=0;m<count;++m)
+		{
+			Material* mat = m_CurrentMaterials[m];
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+			QuadTreeNodeRenderer* r = AddQuadTreeNodeRenderer( matrix, node.subMesh.localAABB, mat, layer, castShadows, true, camera );
+			r->Setup( this, &node );
+#else
+			IntermediateRenderer* r = AddIntermediateRenderer (matrix, node.mesh, mat, layer, castShadows, true, 0, camera);
+#endif
+			r->SetLightmapIndexIntNoDirty(m_LightmapIndex);
+			#if UNITY_EDITOR
+			r->SetScaleInLightmap(m_LightmapSize);
+			r->SetInstanceID (m_InstanceID);
+			#endif
+		}
+	}
+	else 
+	{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+		QuadTreeNodeRenderer* r = AddQuadTreeNodeRenderer( matrix, node.subMesh.localAABB, m_CurrentBaseMaterial, layer, castShadows, true, camera );
+		r->Setup( this, &node );
+#else
+		IntermediateRenderer* r = new IntermediateRenderer( matrix, node.mesh, m_CurrentBaseMaterial, layer, castShadows, true, 0 );
+#endif
+		r->SetLightmapIndexIntNoDirty(m_LightmapIndex);
+		#if UNITY_EDITOR
+		r->SetScaleInLightmap(m_LightmapSize);
+		r->SetInstanceID (m_InstanceID);
+		#endif
+	}
+}
+
+void TerrainRenderer::BuildRenderer (QuadTreeNode &node, int edgeMask)
+{
+	// Build mesh
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+	RemoveMesh(node);
+#else
+	DestroySingleObject (node.mesh);
+
+	node.mesh = NEW_OBJECT (Mesh);
+	node.mesh->Reset();
+	node.mesh->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);
+
+	node.mesh->SetHideFlags(Object::kDontSave);
+#endif
+
+	AABB bounds = m_TerrainData->GetHeightmap().GetBounds(node.x, node.y, node.level);
+
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+	node.subMesh.localAABB = bounds;
+	node.updateMesh = true;
+	node.updateIndices = true;
+#else
+	node.mesh->SetBounds(bounds);
+	m_TerrainData->GetHeightmap().UpdatePatchMesh(*node.mesh, node.x, node.y, node.level, edgeMask, this);
+	m_TerrainData->GetHeightmap().UpdatePatchIndices(*node.mesh, node.x, node.y, node.level, edgeMask);
+	Assert(node.mesh->GetBounds().GetCenter () == bounds.GetCenter() && node.mesh->GetBounds().GetExtent() == bounds.GetExtent ());
+#endif
+}
+
+
+void TerrainRenderer::RecursiveRenderMeshes (QuadTreeNode &node, Heightmap &heightmap)
+{
+	// The node itself needs to be rendered
+	if (node.visibility == kVisibilityDrawSelf)
+	{
+		int newEdgeMask = CalculateEdgeMask(node);
+		// We didn't render the node last frame. So we need to build from scratch
+		if (node.oldVisibility != kVisibilityDrawSelf)
+		{
+			BuildRenderer(node, newEdgeMask);
+			node.edgeMask = newEdgeMask;
+			RenderNode(node);
+		}
+		// If  highest lod error is infinity we rebuild the mesh constantly
+		// (This is set while the terrain is being painted)
+		else if (node.maxHeightError == std::numeric_limits<float>::infinity())
+		{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+			node.updateMesh = true;
+#else
+			heightmap.UpdatePatchMesh(*node.mesh, node.x, node.y, node.level, newEdgeMask, this);
+#endif
+			if (newEdgeMask != node.edgeMask)
+			{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+				node.updateIndices = true;
+#else
+				heightmap.UpdatePatchIndices(*node.mesh, node.x, node.y, node.level, newEdgeMask);
+#endif
+				node.edgeMask = newEdgeMask;		
+			}
+			
+			RenderNode(node);
+		}
+		// The edge mask has changed, we need to update the triangle indices
+		else if (newEdgeMask != node.edgeMask)
+		{
+#ifdef TERRAIN_PREFER_VBO_OVER_MESH
+			node.updateIndices = true;
+#else
+			heightmap.UpdatePatchIndices(*node.mesh, node.x, node.y, node.level, newEdgeMask);
+#endif
+			node.edgeMask = newEdgeMask;
+			RenderNode(node);
+		}
+		// Nothing changed just paint
+		else
+		{
+			RenderNode(node);
+		}
+		
+		// All old children need to be removed!
+		if (node.oldVisibility == kVisibilityDrawChild)
+		{
+			for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+			{
+				QuadTreeNode *childNode = FindChild (node, i);
+				Assert (childNode != NULL);
+				RecursiveRemoveMeshes (*childNode);
+			}
+		}
+	}
+	// Some children of the node need to be rendered
+	else if (node.visibility == kVisibilityDrawChild)
+	{
+		// Remove the old render mesh
+		if (node.oldVisibility == kVisibilityDrawSelf)
+			RemoveMesh (node);
+		
+		// Recurse into children
+		for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+		{
+			QuadTreeNode *childNode = FindChild (node, i);
+			RecursiveRenderMeshes (*childNode, heightmap);
+		}
+	}
+	// Node is invisible
+	else
+	{
+		// All old children need to be removed!
+		if (node.oldVisibility == kVisibilityDrawChild)
+		{
+			for (int i=kDirectionLeftUp;i<=kDirectionRightDown;i++)
+			{
+				QuadTreeNode *childNode = FindChild (node, i);
+				RecursiveRemoveMeshes (*childNode);
+			}
+		}
+		// Remove the old render mesh
+		else if (node.oldVisibility == kVisibilityDrawSelf)
+			RemoveMesh (node);
+	}
+		
+	node.oldVisibility = node.visibility;
+}
+
+Mesh* GetMeshForPatch(int x, int y, int level, Heightmap& heightmap, TerrainRenderer* terrainRenderer)
+{
+	// Build mesh		
+	Mesh* mesh = NEW_OBJECT (Mesh);
+	mesh->Reset();
+	mesh->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);
+	
+	mesh->SetHideFlags(Object::kDontSave);
+	
+	// judging by CalculateEdgeMask() the edgeMask equal to 15 means all the neighbouring
+	// patches are visible	
+	heightmap.UpdatePatchMesh(*mesh, x, y, level, 15, terrainRenderer);
+	heightmap.UpdatePatchIndices(*mesh, x, y, level, 15);
+	
+	mesh->RecalculateBounds();
+	
+	return mesh;
+}
+
+std::vector<Mesh*> TerrainRenderer::GetMeshPatches()
+{
+	std::vector<Mesh*> meshes;
+	Heightmap &heightmap = m_TerrainData->GetHeightmap();
+	
+	const int level = 0;
+	int xPatches = GetPatchCountX(level);
+	int yPatches = GetPatchCountY(level);
+	
+	for (int y = 0; y < yPatches; y++)
+	{
+		for (int x = 0; x < xPatches; x++)
+		{
+			Mesh* mesh = GetMeshForPatch(x, y, level, heightmap, this);
+			mesh->SetName(Format("%s[%i][%i]", m_TerrainData->GetName(), x, y).c_str());
+			meshes.push_back(mesh);
+		}
+	}
+	
+	return meshes;
+}
+
+#endif // ENABLE_TERRAIN