From 15740faf9fe9fe4be08965098bbf2947e096aeeb Mon Sep 17 00:00:00 2001
From: chai <chaifix@163.com>
Date: Wed, 14 Aug 2019 22:50:43 +0800
Subject: +Unity Runtime code

---
 Runtime/Terrain/DetailDatabase.cpp | 1106 ++++++++++++++++++++++++++++++++++++
 1 file changed, 1106 insertions(+)
 create mode 100644 Runtime/Terrain/DetailDatabase.cpp

(limited to 'Runtime/Terrain/DetailDatabase.cpp')

diff --git a/Runtime/Terrain/DetailDatabase.cpp b/Runtime/Terrain/DetailDatabase.cpp
new file mode 100644
index 0000000..bc11b30
--- /dev/null
+++ b/Runtime/Terrain/DetailDatabase.cpp
@@ -0,0 +1,1106 @@
+#include "UnityPrefix.h"
+#include "DetailDatabase.h"
+
+#if ENABLE_TERRAIN
+
+#include "Runtime/Filters/Renderer.h"
+#include "Runtime/Filters/Mesh/LodMeshFilter.h"
+#include "Runtime/Shaders/Material.h"
+#include "Runtime/Geometry/TextureAtlas.h"
+#include "PerlinNoise.h"
+#include "TerrainData.h"
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/Graphics/LightmapSettings.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+
+
+const int kClampedVertexCount = 50000;
+enum { kResolutionPerPatch = 8 };
+
+static void UpdateAtlasTextureColorSpace(Texture2D* atlasTexture, Texture2D** sourceTextures, int sourceTextureCount)
+{
+	for (int i = 0; i < sourceTextureCount; ++i)
+	{
+		if (sourceTextures[i] != NULL && sourceTextures[i]->GetStoredColorSpace() != kTexColorSpaceLinear)
+		{
+			atlasTexture->SetStoredColorSpaceNoDirtyNoApply (kTexColorSpaceSRGB);
+			return;
+		}
+	}
+	atlasTexture->SetStoredColorSpaceNoDirtyNoApply(kTexColorSpaceLinear);
+}
+
+// 8x8 dither table from http://en.wikipedia.org/wiki/Ordered_dithering
+const float kDitherTable[] = {
+	1, 49, 13, 61, 4, 52, 16, 64,
+	33, 17, 45, 29, 36, 20, 48, 32,
+	9, 57, 5, 53, 12, 60, 8, 56,
+	41, 25, 37, 21, 44, 28, 40, 24,
+	3, 51, 15, 63, 2, 50, 14, 62,
+	35, 19, 47, 31, 34, 18, 46, 30,
+	11, 59, 7, 55, 10, 58, 6, 54,
+	43, 27, 39, 23, 42, 26, 38, 22,
+};
+
+DetailDatabase::DetailDatabase (TerrainData* terrainData, TreeDatabase* database)
+{
+	m_TerrainData = terrainData;
+	m_TreeDatabase = database;
+	m_WavingGrassTint = ColorRGBAf (0.7f, 0.6f, 0.5f, 0.0f);
+	m_WavingGrassStrength = .5F;
+	m_WavingGrassAmount = .5F;
+	m_WavingGrassSpeed = .5F;
+	m_PatchCount = 0;
+	m_PatchSamples = kResolutionPerPatch;
+	m_IsPrototypesDirty = true;
+	m_AtlasTexture = NULL;
+}
+
+bool DetailDatabase::IsPatchEmpty (int x, int y) const
+{
+	return GetPatch(x,y).numberOfObjects.empty ();
+}
+bool DetailDatabase::IsPatchDirty (int x, int y) const
+{
+	return GetPatch(x,y).dirty;
+}
+
+void DetailDatabase::SetDetailResolution (int resolution, int resolutionPerPatch)
+{
+	m_PatchCount = clamp<int>(resolution / resolutionPerPatch, 0, 10000);
+	m_PatchSamples = clamp<int>(resolutionPerPatch, 8, 1000);
+	
+	m_Patches.clear();
+	m_Patches.resize (m_PatchCount * m_PatchCount);
+
+	SetDirty();
+} 
+
+void DetailDatabase::SetDetailPrototypesDirty ()
+{
+	m_IsPrototypesDirty = true;
+}
+
+void DetailDatabase::ResetDirtyDetails ()
+{
+	for (int i=0;i<m_Patches.size();i++)
+		m_Patches[i].dirty = false;
+}
+
+int DetailDatabase::AddLayerIndex (int detailIndex, DetailPatch &patch)
+{
+	for (int i=0;i<patch.layerIndices.size();i++)
+	{
+		if (patch.layerIndices[i] == detailIndex)
+			return i;
+	}
+	patch.layerIndices.push_back (detailIndex);
+	patch.numberOfObjects.resize (patch.numberOfObjects.size() + m_PatchSamples * m_PatchSamples);
+	return patch.layerIndices.size() - 1;
+}
+
+void DetailDatabase::RemoveLocalLayerIndex (int detailIndex, DetailPatch& patch)
+{
+	Assert(detailIndex >= 0 || detailIndex < patch.layerIndices.size());
+	
+	// Remove detail index out of numberofObjectsArray
+	int begin = detailIndex * m_PatchSamples * m_PatchSamples;
+	patch.numberOfObjects.erase (patch.numberOfObjects.begin() + begin, patch.numberOfObjects.begin() + begin + m_PatchSamples * m_PatchSamples);
+	
+	patch.layerIndices.erase(patch.layerIndices.begin() + detailIndex);
+}
+
+int DetailDatabase::GetSupportedLayers (int xBase, int yBase, int totalWidth, int totalHeight, int *buffer) const
+{
+	if( m_PatchCount <= 0 )
+	{
+		ErrorString ("Terrain has zero detail resolution");
+		return 0;
+	}
+	
+	int* enabledLayers;
+	int prototypeCount = m_DetailPrototypes.size ();
+	ALLOC_TEMP(enabledLayers, int, prototypeCount);
+	memset(enabledLayers,0,sizeof (int) * prototypeCount);
+	
+	int minPatchX = clamp(xBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int minPatchY = clamp(yBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchX = clamp((xBase+totalWidth) / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchY = clamp((yBase+totalHeight) / m_PatchSamples, 0, m_PatchCount - 1);
+	
+	for (int patchY=minPatchY;patchY<=maxPatchY;patchY++)
+	{
+		for (int patchX=minPatchX;patchX<=maxPatchX;patchX++)
+		{
+			int minX = clamp (xBase - patchX * m_PatchSamples, 0, m_PatchSamples - 1);
+			int minY = clamp (yBase - patchY * m_PatchSamples, 0, m_PatchSamples - 1);
+	
+			int maxX = clamp (xBase + totalWidth - patchX * m_PatchSamples, 0, m_PatchSamples);
+			int maxY = clamp (yBase + totalHeight - patchY * m_PatchSamples, 0, m_PatchSamples);
+	
+			int width = maxX - minX;
+			int height = maxY - minY;
+			if (width == 0 || height == 0)
+				continue;
+	
+			const DetailPatch& patch = GetPatch(patchX, patchY);
+			for (int l=0;l<patch.layerIndices.size();l++)
+			{
+				int layer = patch.layerIndices[l];
+				enabledLayers[layer] = 1;
+			}
+		}	
+	}
+	
+	int enabledCount = 0;
+	for (int i=0;i<prototypeCount;i++)
+	{
+		if (enabledLayers[i])
+		{
+			if (buffer) 
+				buffer[enabledCount] = i;
+			enabledCount++;
+		}
+	}
+	
+	return enabledCount;
+}
+
+
+void DetailDatabase::GetLayer (int xBase, int yBase, int totalWidth, int totalHeight, int detailIndex, int *buffer) const
+{
+	if( m_PatchCount <= 0 )
+	{
+		ErrorString ("Terrain has zero detail resolution");
+		return;
+	}
+	
+	int minPatchX = clamp(xBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int minPatchY = clamp(yBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchX = clamp((xBase+totalWidth) / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchY = clamp((yBase+totalHeight) / m_PatchSamples, 0, m_PatchCount - 1);
+	
+	for (int patchY=minPatchY;patchY<=maxPatchY;patchY++)
+	{
+		for (int patchX=minPatchX;patchX<=maxPatchX;patchX++)
+		{
+			int minX = clamp(xBase - patchX * m_PatchSamples, 0, m_PatchSamples - 1);
+			int minY = clamp(yBase - patchY * m_PatchSamples, 0, m_PatchSamples - 1);
+	
+			int maxX = clamp(xBase + totalWidth - patchX * m_PatchSamples, 0, m_PatchSamples);
+			int maxY = clamp(yBase + totalHeight - patchY * m_PatchSamples, 0, m_PatchSamples);
+	
+			int width = maxX - minX;
+			int height = maxY - minY;
+			if (width == 0 || height == 0)
+				continue;
+	
+			int xOffset = minX + patchX * m_PatchSamples - xBase;
+			int yOffset = minY + patchY * m_PatchSamples - yBase;
+			
+			const DetailPatch &patch = GetPatch(patchX, patchY);
+			
+			const UInt8 *numberOfObjects = &patch.numberOfObjects[0];
+			for (int l=0;l<patch.layerIndices.size();l++)
+			{
+				int layer = patch.layerIndices[l];
+				if (layer != detailIndex)
+					continue;
+					
+				for (int y=0;y<height;y++)
+				{
+					for (int x=0;x<width;x++)
+					{
+						int nbOfObjects = numberOfObjects[GetIndex(minX + x, minY + y, l)];
+						buffer[x + xOffset + (y + yOffset) * totalWidth] = nbOfObjects;
+					}
+				}	
+			}
+		}	
+	}
+}
+
+void DetailDatabase::SetLayer (int xBase, int yBase, int totalWidth, int totalHeight, int detailIndex, const int *buffer)
+{
+	if (detailIndex >= m_DetailPrototypes.size())
+	{
+		ErrorString ("Detail index out of bounds in DetailDatabase.SetLayers");
+		return;
+	}
+	if (m_PatchCount <= 0)
+	{
+		ErrorString ("Terrain has zero detail resolution");
+		return;
+	}
+	int minPatchX = clamp(xBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int minPatchY = clamp(yBase / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchX = clamp((xBase+totalWidth) / m_PatchSamples, 0, m_PatchCount - 1);
+	int maxPatchY = clamp((yBase+totalHeight) / m_PatchSamples, 0, m_PatchCount - 1);
+	
+	for (int patchY=minPatchY;patchY<=maxPatchY;patchY++)
+	{
+		for (int patchX=minPatchX;patchX<=maxPatchX;patchX++)
+		{
+			int minX = clamp(xBase - patchX * m_PatchSamples, 0, m_PatchSamples - 1);
+			int minY = clamp(yBase - patchY * m_PatchSamples, 0, m_PatchSamples - 1);
+	
+			int maxX = clamp(xBase + totalWidth - patchX * m_PatchSamples, 0, m_PatchSamples);
+			int maxY = clamp(yBase + totalHeight - patchY * m_PatchSamples, 0, m_PatchSamples);
+	
+			int width = maxX - minX;
+			int height = maxY - minY;
+			if (width == 0 || height == 0)
+				continue;
+	
+			int xOffset = minX + patchX * m_PatchSamples - xBase;
+			int yOffset = minY + patchY * m_PatchSamples - yBase;
+			
+			DetailPatch& patch = GetPatch(patchX, patchY);
+			
+			int localLayerIndex = AddLayerIndex(detailIndex, patch);
+			UInt8* numberOfObjects = &patch.numberOfObjects[0];
+
+			for (int y=0;y<height;y++)
+			{
+				for (int x=0;x<width;x++)
+				{
+					// TODO: Is this the right order?
+					int nb = clamp(buffer[x + xOffset + (y + yOffset) * totalWidth], 0, 255);
+					int nbIndex = GetIndex(minX + x, minY + y, localLayerIndex);
+					if (nb != numberOfObjects[nbIndex])
+					{
+						numberOfObjects[nbIndex] = nb;
+						patch.dirty = true;
+					}
+				}	
+			}
+			
+			// Detect if this patch has zero details on this layer
+			// In that case delete the layer completely to save space
+			unsigned hasSomething = 0;
+			int oneLayerSampleCount = m_PatchSamples * m_PatchSamples;
+			for (int i=0;i<oneLayerSampleCount;i++)
+				hasSomething += numberOfObjects[localLayerIndex * oneLayerSampleCount + i];
+			
+			if (hasSomething == 0)
+				RemoveLocalLayerIndex(localLayerIndex, patch);
+		}	
+	}
+	SetDirty ();
+	
+	// All detail renderers will reload details that have patch.dirty set
+	// Then reset the patch.dirty = false on all patches.
+	m_TerrainData->UpdateUsers (TerrainData::kRemoveDirtyDetailsImmediately);
+	ResetDirtyDetails();
+}
+
+void DetailDatabase::CleanupPrototype (DetailPrototype &proto, string const& error)
+{
+	proto.vertices.clear();
+	proto.uvs.clear();
+	proto.colors.clear();
+	proto.triangles.clear();
+}
+
+
+DetailDatabase::~DetailDatabase ()
+{
+	DestroySingleObject(m_AtlasTexture);
+}
+
+namespace DetailDatabase_Static
+{
+static SHADERPROP(MainTex);
+} // namespace DetailDatabase_Static
+ 
+#if UNITY_EDITOR
+// For thread loading we need to know the textures. Going through the meshes then textures is not thread safe.
+void DetailDatabase::SetupPreloadTextureAtlasData ()
+{
+	m_PreloadTextureAtlasData.resize(m_DetailPrototypes.size());
+
+	Texture2D** sourceTextures;
+	ALLOC_TEMP(sourceTextures, Texture2D*, m_DetailPrototypes.size());
+	
+	RefreshPrototypesStep1(sourceTextures);
+
+	for (int i=0;i<m_DetailPrototypes.size();i++)
+	{
+		m_PreloadTextureAtlasData[i] = sourceTextures[i];
+		if (sourceTextures[i] == NULL)
+		{
+			WarningString("Missing detail texture in Terrain, degraded loading performance");
+			m_PreloadTextureAtlasData.clear();
+			break;
+		}
+	}
+	
+	SetDetailPrototypesDirty();
+}
+
+#endif
+
+void DetailDatabase::GenerateTextureAtlasThreaded ()
+{
+	if (!m_PreloadTextureAtlasData.empty())
+	{
+		AssertIf(m_PreloadTextureAtlasData.size() != m_DetailPrototypes.size());
+		
+		Texture2D** sourceTextures;
+		ALLOC_TEMP(sourceTextures, Texture2D*, m_PreloadTextureAtlasData.size());
+		
+		int i;
+		for (i=0;i<m_PreloadTextureAtlasData.size();i++)
+		{
+			Texture2D* tex = dynamic_pptr_cast<Texture2D*> (InstanceIDToObjectThreadSafe(m_PreloadTextureAtlasData[i].GetInstanceID()));
+			if (tex == NULL)
+				break;
+			sourceTextures[i] = tex;
+		}
+		
+		if (i == m_PreloadTextureAtlasData.size())
+		{
+			AssertIf (m_AtlasTexture != NULL);
+
+			m_AtlasTexture = NEW_OBJECT_FULL(Texture2D, kCreateObjectFromNonMainThread);
+			m_AtlasTexture->Reset();
+			m_AtlasTexture->AwakeFromLoadThreaded();
+			
+			// ok, just from performance standpoint we don't want to upload texture here
+			// or get an assert from uninited texture, so, let's cheat
+			m_AtlasTexture->HackSetAwakeDidLoadThreadedWasCalled();
+
+			m_PreloadTextureAtlasUVLayout.resize(m_PreloadTextureAtlasData.size());
+			
+			UpdateAtlasTextureColorSpace(m_AtlasTexture, sourceTextures, m_PreloadTextureAtlasData.size());
+			PackTextureAtlasSimple (m_AtlasTexture, 2048, m_PreloadTextureAtlasData.size(), sourceTextures, &m_PreloadTextureAtlasUVLayout[0], 0, false, false);
+		}
+	}
+}
+
+void DetailDatabase::RefreshPrototypesStep1 (Texture2D** sourceTextures)
+{
+	using namespace DetailDatabase_Static;
+
+	for (int i=0;i<m_DetailPrototypes.size();i++)
+	{
+		DetailPrototype& proto = m_DetailPrototypes[i];
+		sourceTextures[i] = NULL;
+		
+		GameObject *prototype = proto.prototype;
+		if (proto.usePrototypeMesh && prototype)
+		{
+			Renderer* renderer = prototype->QueryComponent (Renderer);
+			if (renderer == NULL)
+			{
+				CleanupPrototype(proto, Append("Missing renderer ", prototype->GetName()));
+				continue;
+			}
+			
+			if (renderer->GetMaterialCount() != 1)
+			{
+				CleanupPrototype(proto, Append(proto.prototype->GetName(), " must have exactly one material."));
+				continue;
+			}
+			
+			Material *sharedMaterial = renderer->GetMaterial (0);
+			if (sharedMaterial == NULL)
+			{
+				CleanupPrototype(proto, Append("Missing material ", proto.prototype->GetName()));
+				continue;
+			}
+			
+			MeshFilter *filter = prototype->QueryComponent(MeshFilter);	
+			if (filter == NULL)
+			{
+				CleanupPrototype(proto, Append("Missing mesh filter ", proto.prototype->GetName()));
+				continue;
+			}
+
+			Mesh* mesh = filter->GetSharedMesh();
+			if (mesh == NULL)
+			{
+				CleanupPrototype(proto, Append ("Missing mesh ", proto.prototype->GetName()));
+				continue;
+			}
+			
+			proto.vertices.assign (mesh->GetVertexBegin(), mesh->GetVertexEnd());
+			if (proto.vertices.empty())
+			{
+				CleanupPrototype(proto, Append ("No vertices available ", prototype->GetName()));
+				continue;
+			}
+
+			// Colors and normals are not optional here. Default to something
+			if (mesh->IsAvailable (kShaderChannelColor))
+			{
+				proto.colors.assign (mesh->GetColorBegin (), mesh->GetColorEnd () );
+			} 
+			else
+			{
+				proto.colors.clear ();				
+				proto.colors.resize (mesh->GetVertexCount(), ColorRGBA32(0xFFFFFFFF));
+			} 
+
+			if (mesh->IsAvailable (kShaderChannelNormal))
+			{	
+				proto.normals.assign(mesh->GetNormalBegin (), mesh->GetNormalEnd ());
+			}
+			else
+			{
+				proto.normals.clear ();				
+				proto.normals.resize (mesh->GetVertexCount(), Vector3f(0,1,0));
+			}
+
+			if (mesh->IsAvailable (kShaderChannelTexCoord0))
+			{	
+				proto.uvs.assign (mesh->GetUvBegin(0), mesh->GetUvEnd(0));
+			}
+			else
+			{
+				CleanupPrototype(proto, Append("No uvs available ", proto.prototype->GetName()));
+				continue;
+			}
+
+			Mesh::TemporaryIndexContainer tempBuffer;
+			mesh->GetTriangles (tempBuffer);
+			proto.triangles.assign (tempBuffer.begin(), tempBuffer.end());
+
+			if (proto.triangles.empty())
+			{
+				CleanupPrototype(proto, Append("No triangles available ", proto.prototype->GetName()));
+				continue;
+			}
+
+			if (sharedMaterial)
+				sourceTextures[i] = dynamic_pptr_cast <Texture2D*>(sharedMaterial->GetTexture (kSLPropMainTex));
+		}
+		// We don't have a mesh, but we have a texture: it's grass quads
+		else if( !proto.usePrototypeMesh && proto.prototypeTexture.IsValid() )
+		{
+			float halfWidth = 0.5F;
+			float height = 1.0F;
+			// color modifier at the top of the grass.
+			// billboard top vertex color = topColor * perlinNoise * 2
+			// Was 1.5f before we doublemultiplied
+			ColorRGBA32 topColor = GfxDevice::ConvertToDeviceVertexColor( ColorRGBA32 (255, 255, 255, 255) );
+			ColorRGBA32 bottomColor = GfxDevice::ConvertToDeviceVertexColor( ColorRGBA32 (160,160,160, 0) );
+
+			Vector3f vertices[] = { 
+				Vector3f (-halfWidth, 0, 0),
+				Vector3f (-halfWidth, height, 0),
+				Vector3f (halfWidth, height, 0),
+				Vector3f (halfWidth, 0, 0),
+			};
+
+			ColorRGBA32 colors[] = {
+				bottomColor, topColor, topColor, bottomColor,
+			};
+			Vector2f uvs[] = {
+				Vector2f (0, 0), Vector2f (0, 1), Vector2f (1, 1), Vector2f (1, 0),
+			};
+			UInt16 triangles[] = {
+				0, 1, 2, 2, 3, 0,
+			};
+
+			const int actualVertexCount = 4;
+			const int actualIndexCount = 6;
+
+			// skip normals creation, since they will be taken from the terrain in GenerateMesh()
+
+			proto.vertices.assign (vertices, vertices + actualVertexCount);
+			proto.colors.assign (colors, colors + actualVertexCount);
+			proto.uvs.assign (uvs, uvs + actualVertexCount);
+			proto.triangles.assign (triangles, triangles + actualIndexCount);
+			sourceTextures[i] = proto.prototypeTexture;
+		}
+		else
+		{
+			if (proto.prototype)
+				CleanupPrototype(proto, Append("Missing prototype ", proto.prototype->GetName()));
+			else
+				CleanupPrototype(proto, "Missing prototype");
+			continue;
+		}
+	}
+}
+
+
+void DetailDatabase::RefreshPrototypes ()
+{
+	Texture2D** sourceTextures;
+	ALLOC_TEMP(sourceTextures, Texture2D*, m_DetailPrototypes.size());
+
+	RefreshPrototypesStep1(sourceTextures);
+
+	// Normal non-threaded creation mode
+	if (m_AtlasTexture == NULL || m_AtlasTexture->IsInstanceIDCreated())
+	{
+		// Not created yet 
+		if (m_AtlasTexture == NULL)
+		{
+			m_AtlasTexture = CreateObjectFromCode<Texture2D>();
+			m_AtlasTexture->SetHideFlags (Object::kHideAndDontSave);
+			m_AtlasTexture->InitTexture(2, 2, kTexFormatARGB32, Texture2D::kMipmapMask, 1);
+			m_AtlasTexture->SetWrapMode(kTexWrapClamp);
+		}
+		
+		// TODO: Make 4096 a property & clamp to GFX card, detail settings
+		Rectf* rects;
+		ALLOC_TEMP(rects, Rectf, m_DetailPrototypes.size());
+		
+		UpdateAtlasTextureColorSpace(m_AtlasTexture, sourceTextures, m_DetailPrototypes.size());
+		PackTextureAtlasSimple (m_AtlasTexture, 2048, m_DetailPrototypes.size(), sourceTextures, rects, 0, true, false);
+		
+		for (int i=0;i<m_DetailPrototypes.size();i++)
+		{
+			DetailPrototype &proto = m_DetailPrototypes[i];
+			Rectf r = rects[i];
+			float w = r.Width();
+			float h = r.Height();
+			for (int v=0;v<proto.uvs.size();v++)
+			{
+				proto.uvs[v].x = proto.uvs[v].x * w + r.x;
+				proto.uvs[v].y = proto.uvs[v].y * h + r.y;
+			}
+		}
+	}
+	// Generated in loading thread - Just upload
+	else
+	{
+		Object::AllocateAndAssignInstanceID(m_AtlasTexture);
+		m_AtlasTexture->SetHideFlags (Object::kHideAndDontSave);
+		m_AtlasTexture->SetWrapMode( kTexWrapClamp );
+		
+		AssertIf (m_PreloadTextureAtlasUVLayout.size() != m_DetailPrototypes.size());
+		for (int i=0;i<m_DetailPrototypes.size();i++)
+		{
+			DetailPrototype &proto = m_DetailPrototypes[i];
+			Rectf r = m_PreloadTextureAtlasUVLayout[i];
+			float w = r.Width();
+			float h = r.Height();
+			for (int v=0;v<proto.uvs.size();v++)
+			{
+				proto.uvs[v].x = proto.uvs[v].x * w + r.x;
+				proto.uvs[v].y = proto.uvs[v].y * h + r.y;
+			}
+		}
+		
+		m_AtlasTexture->AwakeFromLoad(kDefaultAwakeFromLoad);
+	}
+	
+	m_IsPrototypesDirty = false;
+}
+
+
+void DetailDatabase::SetDirty ()
+{
+	m_TerrainData->SetDirty ();
+}
+
+void DetailDatabase::SetDetailPrototypes (const vector<DetailPrototype> & detailPrototypes)
+{
+	m_DetailPrototypes = detailPrototypes;
+	RefreshPrototypes ();
+	SetDirty ();
+	m_TerrainData->UpdateUsers (TerrainData::kFlushEverythingImmediately);
+}
+
+void DetailDatabase::RemoveDetailPrototype (int index)
+{
+	#if UNITY_EDITOR
+	
+	if( index < 0 || index >= m_DetailPrototypes.size() )
+	{
+		ErrorString("invalid detail prototype index");
+		return;
+	}
+	
+	// erase detail prototype
+	m_DetailPrototypes.erase( m_DetailPrototypes.begin() + index );
+	
+	// update detail patches
+	for( size_t i = 0; i < m_Patches.size(); ++i )
+	{
+		DetailPatch& patch = m_Patches[i];
+		int localIndex = -1;
+		for( size_t j = 0; j < patch.layerIndices.size(); ++j )
+		{
+			if( patch.layerIndices[j] == index )
+				localIndex = j;
+			else if( patch.layerIndices[j] > index )
+				--patch.layerIndices[j];
+		}
+		if( localIndex == -1 )
+			continue;
+		
+		AssertIf( patch.numberOfObjects.size() != patch.layerIndices.size() * m_PatchSamples * m_PatchSamples );
+		
+		patch.layerIndices.erase( patch.layerIndices.begin() + localIndex );
+		patch.numberOfObjects.erase(
+			patch.numberOfObjects.begin() + localIndex * m_PatchSamples * m_PatchSamples,
+			patch.numberOfObjects.begin() + (localIndex+1) * m_PatchSamples * m_PatchSamples );
+	}
+	
+	RefreshPrototypes ();
+	SetDirty();
+	m_TerrainData->UpdateUsers (TerrainData::kFlushEverythingImmediately);
+	
+	#else
+	ErrorString("only implemented in editor");
+	#endif
+}
+
+static void CopyVertex (Vector3f *src, Vector3f *dst, const Matrix4x4f &transform, int offset, int count)
+{
+	for (int i=0;i<count;i++)
+		dst[i+offset] = transform.MultiplyPoint3(src[i]);
+}
+
+static void CopyVertex (Vector3f pos, Vector3f *dst, int offset, int count)
+{
+	for (int i=0;i<count;i++)
+		dst[i+offset] = pos;
+}
+
+static void CopyNormal (Vector3f* src, Vector3f* dst, Quaternionf rot, int offset, int count)
+{
+	for (int i=0;i<count;i++)
+		dst[i+offset] = RotateVectorByQuat (rot, src[i]);
+}
+
+static void CopyNormalFromTerrain (const Heightmap& heightmap, float normalizedX, float normalizedZ, Vector3f* dst, int offset, int count)
+{
+	Vector3f terrainNormal = heightmap.GetInterpolatedNormal(normalizedX, normalizedZ);
+	
+	for (int i = 0; i < count; i++)
+		dst[i+offset] = terrainNormal;
+}
+
+static void CopyUV (Vector2f* src, Vector2f *dst, int offset, int count)
+{
+	for (int i=0;i<count;i++)
+		dst[i+offset] = src[i];
+}
+
+static void CopyTangents (Vector2f* src, Vector4f *dst, int offset, int count)
+{
+	for (int i = 0; i < count; i++)
+	{
+		Vector2f srcVector = src[i];
+		Vector4f& dstVector = dst[i+offset];
+
+		dstVector.x = srcVector.x;
+		dstVector.y = srcVector.y;
+	}
+}
+
+static void CopyUVFromTerrain (float normalizedX, float normalizedZ, Vector2f *dst, int offset, int count)
+{
+	Vector2f lightmapUV(normalizedX, normalizedZ);
+	for (int i = 0; i < count; i++)
+		dst[i+offset] = lightmapUV;
+}
+
+inline ColorRGBA32 MultiplyDouble (const ColorRGBA32 &inC0, const ColorRGBA32 &inC1) 
+{
+	return ColorRGBA32 (
+		std::min (((int)inC0.r * (int)inC1.r) / 128, 255), 
+		std::min (((int)inC0.g * (int)inC1.g) / 128, 255), 
+		std::min (((int)inC0.b * (int)inC1.b) / 128, 255), 
+		std::min (((int)inC0.a * (int)inC1.a) / 128, 255)
+	);
+}
+
+static void CopyColor (ColorRGBA32* src, ColorRGBA32* dst, ColorRGBA32 scale, int offset, int count)
+{
+	for (int i=0;i<count;i++)
+		dst[i+offset] = src[i] * scale;
+}
+
+/*Rectf DetailDatabase::GetNormalizedArea (int x, int y)
+{
+	float fx = (float)x / m_PatchCount;
+	float fy = (float)y / m_PatchCount;
+	float size = 1.0F / m_PatchCount;
+	return Rectf (fx, fy, fx+size, fy+size);
+}
+*/
+/*
+void DetailDatabase::GenerateBounds (DetailPatch &patch, int patchX, int patchY)
+{
+	if (patch.numberOfObjects.size() != 0)
+	{
+		Mesh mesh = new Mesh ();
+		
+		GenerateMesh (mesh, patch, patchX, patchY, m_Heightmap.size, false, DetailRenderMode.Grass);
+		patch.bounds = mesh.bounds;
+//			Debug.Log(patch.bounds.min);
+//			Debug.Log(patch.bounds.max);
+		DestroyImmediate (mesh);
+	}
+}
+*/
+
+PROFILER_INFORMATION(gBuildDetailMesh, "Terrain.Details.BuildPatchMesh", kProfilerRender)
+PROFILER_INFORMATION(gExtractLightmap, "DetailMesh.ExtractLightmap", kProfilerRender);
+PROFILER_INFORMATION(gSetup, "DetailMesh.Setup", kProfilerRender);
+PROFILER_INFORMATION(gBuildData, "DetailMesh.BuildData", kProfilerRender);
+PROFILER_INFORMATION(gAssignToMesh, "DetailMesh.AssignToMesh", kProfilerRender);
+
+Mesh* DetailDatabase::BuildMesh (int patchX, int patchY, Vector3f size, int lightmapIndex, DetailRenderMode renderMode, float density)
+{
+	int totalTriangleCount, totalVertexCount;
+	
+	PROFILER_AUTO(gBuildDetailMesh, NULL)
+
+	DetailPatch &patch = GetPatch (patchX, patchY);
+	ComputeVertexAndTriangleCount(patch, renderMode, density, &totalVertexCount, &totalTriangleCount);
+	if (totalTriangleCount == 0 || totalVertexCount == 0)
+		return NULL;
+	else
+	{
+		Mesh* mesh = NEW_OBJECT(Mesh);
+		mesh->Reset();
+		mesh->AwakeFromLoad(kInstantiateOrCreateFromCodeAwakeFromLoad);
+
+		mesh->SetHideFlags(Object::kHideAndDontSave);
+		GenerateMesh (*mesh, patchX, patchY, size, lightmapIndex, renderMode, density, totalVertexCount, totalTriangleCount);
+		return mesh;
+	}
+} 
+
+// Fixes bounds of the patch of billboards. Since each quad making a billboard
+// has its vertices collapsed in one point, the bounding box does not take
+// the height nor the width of the billboard into account.
+inline void ExpandDetailBillboardBounds(Mesh& mesh, float detailMaxHalfWidth, float detailMaxHeight)
+{
+	// The origin of the billboard is in the middle of the bottom edge.
+	AABB aabb = mesh.GetBounds();
+
+	// The billboard always faces the camera, so when looking from the top
+	// it's the height of the billboard that extends in the XZ plane.
+	float maxHalfWidth = std::max(detailMaxHalfWidth, detailMaxHeight);
+
+	aabb.m_Extent += Vector3f(maxHalfWidth, 0.5f * detailMaxHeight, maxHalfWidth);
+	aabb.m_Center += Vector3f(0, 0.5f * detailMaxHeight, 0);
+	mesh.SetBounds(aabb);
+}
+
+void DetailDatabase::GenerateMesh (Mesh& mesh, int patchX, int patchY, Vector3f size, int lightmapIndex, DetailRenderMode renderMode, float density, int totalVertexCount, int totalTriangleCount)
+{
+	PROFILER_BEGIN_INTERNAL(gSetup, NULL);
+	DetailPatch &patch = GetPatch (patchX, patchY);
+	Vector3f* vertices;
+	ALLOC_TEMP(vertices, Vector3f, totalVertexCount);
+
+	Vector2f* uvs;
+	ALLOC_TEMP(uvs, Vector2f, totalVertexCount);
+
+	int uv2Count = totalVertexCount;
+
+	Vector2f* uvs2 = NULL;
+	ALLOC_TEMP(uvs2, Vector2f, uv2Count);
+
+	int tangentCount = 0;
+	if (renderMode == kDetailBillboard)
+		tangentCount = totalVertexCount;
+
+	Vector4f* tangents = NULL;
+	ALLOC_TEMP(tangents, Vector4f, tangentCount);
+
+	ColorRGBA32* colors;
+	ALLOC_TEMP(colors, ColorRGBA32, totalVertexCount);
+	
+	int normalCount = totalVertexCount;
+	Vector3f* normals = NULL;
+	ALLOC_TEMP (normals, Vector3f, normalCount);
+		
+	UInt16* triangles;
+	ALLOC_TEMP (triangles, UInt16, totalTriangleCount);
+
+	int triangleCount = 0;
+	int vertexCount = 0;
+	float randomResolutionSize = 1.0F / GetResolution();
+	int res = m_PatchSamples;
+
+	Heightmap* heightmap = &m_TerrainData->GetHeightmap();
+///	int samplesPerHeixel = m_SamplesPerHeixel;
+///	int heixels = m_SamplesPerHeixel;
+		
+//	int xBaseHeightmap = patchX * m_PatchSamples / m_SamplesPerHeixel;
+//	int yBaseHeightmap = patchY * m_PatchSamples / m_SamplesPerHeixel;
+
+	PROFILER_END_INTERNAL;
+		
+	PROFILER_BEGIN_INTERNAL(gBuildData, NULL);
+
+	float detailMaxHalfWidth = 0.0f;
+	float detailMaxHeight = 0.0f;
+
+	for (int i=0;i<patch.layerIndices.size();i++)
+	{
+		DetailPrototype& prototype = m_DetailPrototypes[patch.layerIndices[i]];
+		
+		if (prototype.renderMode != renderMode)
+			continue;
+		
+		Vector3f* prototypeVertices = prototype.vertices.size() > 0 ? &prototype.vertices[0] : NULL;
+		Vector3f* prototypeNormals = prototype.normals.size() > 0 ? &prototype.normals[0] : NULL;
+		Vector2f* prototypeUvs = prototype.uvs.size() > 0 ? &prototype.uvs[0] : NULL;
+		ColorRGBA32* prototypeColors = prototype.colors.size() > 0 ? &prototype.colors[0] : NULL;
+		UInt16* prototypeTris = prototype.triangles.size() > 0 ? &prototype.triangles[0] : NULL;
+		float noiseSpread = prototype.noiseSpread;
+		ColorRGBAf dry = prototype.dryColor; 
+		ColorRGBAf healthy = prototype.healthyColor;
+		
+		float halfGrassWidth = prototype.minWidth * 0.5F;
+		float halfGrassWidthDelta = (prototype.maxWidth - prototype.minWidth) * .5F;
+		float grassHeight = prototype.minHeight;
+		float grassHeightDelta = prototype.maxHeight - prototype.minHeight;
+		int prototypeTrisSize = prototype.triangles.size();
+		int prototypeVerticesSize = prototype.vertices.size();
+		
+		if (prototypeVerticesSize == 0)
+			continue;
+		
+		for (int y=0;y<res;y++)
+		{
+			for (int x=0;x<res;x++)
+			{
+				int nbIndex = y * res + x + i * res * res;
+				int origCount = patch.numberOfObjects[nbIndex];
+				if (origCount == 0)
+					continue;
+				
+				float nx = (float)patchX / m_PatchCount + (float)x / (res * m_PatchCount);
+				float ny = (float)patchY / m_PatchCount + (float)y / (res * m_PatchCount);
+				m_Random.SetSeed (nbIndex + (patchX * m_PatchCount + patchY) * 1013);
+				
+				// Clamp the number of genrated details to not generate more than kClampedVertex vertices
+				int maxCount = (kClampedVertexCount - vertexCount) / prototypeVerticesSize;
+				origCount = std::min(maxCount, origCount);
+
+				int newCount = (int)(origCount * density + (kDitherTable[(x&7)*8+(y&7)] - 0.5f) / 64.0f);
+				for (int k=0;k<newCount;k++)
+				{
+					// Generate position & rotation
+					
+					float normalizedX = nx + m_Random.GetFloat() * randomResolutionSize;
+					float normalizedZ = ny + m_Random.GetFloat() * randomResolutionSize;
+					
+					// normalizedX = nx + 0.5F * randomSize;
+					// normalzedZ = ny + 0.5F * randomSize;
+					Vector3f pos;
+					pos.y = heightmap->GetInterpolatedHeight (normalizedX, normalizedZ);
+					pos.x = normalizedX * size.x;
+					pos.z = normalizedZ * size.z;
+					
+					float noise = PerlinNoise::NoiseNormalized(pos.x * noiseSpread, pos.z * noiseSpread);
+					ColorRGBA32 healthyDryColor = Lerp (dry, healthy, noise);
+					healthyDryColor = GfxDevice::ConvertToDeviceVertexColor (healthyDryColor);
+
+					// set second UVs to point to the fragment of the terrain lightmap underneath the detail mesh
+					CopyUVFromTerrain (normalizedX, normalizedZ, uvs2, vertexCount, prototypeVerticesSize);
+					
+					if (renderMode == kDetailBillboard)
+					{
+						DebugAssertIf (prototypeVerticesSize != 4);
+						DebugAssertIf (prototypeTrisSize != 6);
+
+						float grassX = halfGrassWidth + halfGrassWidthDelta * noise;
+						float grassY = grassHeight + grassHeightDelta * noise;
+
+						detailMaxHalfWidth = std::max(detailMaxHalfWidth, grassX);
+						detailMaxHeight = std::max(detailMaxHeight, grassY);
+						
+						Vector2f billboardSize[] = 
+						{ 
+							Vector2f (-grassX, 0),
+							Vector2f (-grassX, grassY),
+							Vector2f (grassX, grassY),
+							Vector2f (grassX, 0) 
+						};
+						
+						CopyVertex (pos, vertices, vertexCount, prototypeVerticesSize);
+						CopyUV (prototypeUvs, uvs, vertexCount, prototypeVerticesSize);
+
+						// used for offsetting vertices in the vertex shader
+						CopyTangents (billboardSize, tangents, vertexCount, prototypeVerticesSize);
+
+						CopyColor (prototypeColors, colors, healthyDryColor, vertexCount, prototypeVerticesSize);
+
+						CopyNormalFromTerrain(*heightmap, normalizedX, normalizedZ, normals, vertexCount, prototypeVerticesSize);
+						
+						for (int t=0;t<prototypeTrisSize;t++)
+							triangles[t+triangleCount] = prototypeTris[t] + vertexCount;
+												
+						triangleCount += prototypeTrisSize;
+						vertexCount += prototypeVerticesSize;
+					}
+					else
+					{
+						Quaternionf rot = AxisAngleToQuaternion (Vector3f (0,1,0), m_Random.GetFloat() * 6.2831852f);
+						float scaleX = Lerp (prototype.minWidth, prototype.maxWidth, noise);
+						float scaleZ = Lerp (prototype.minHeight, prototype.maxHeight, noise);
+						Vector3f scale = Vector3f (scaleX, scaleZ, scaleX);
+						Matrix4x4f transform;
+						transform.SetTRS (pos, rot, scale);
+						
+						CopyVertex (prototypeVertices, vertices, transform, vertexCount, prototypeVerticesSize);
+						CopyUV (prototypeUvs, uvs, vertexCount, prototypeVerticesSize);
+						CopyColor (prototypeColors, colors, healthyDryColor, vertexCount, prototypeVerticesSize);
+
+						if (renderMode == kDetailMeshGrass)
+						{
+							CopyNormalFromTerrain(*heightmap, normalizedX, normalizedZ, normals, vertexCount, prototypeVerticesSize);
+						}
+						else if (normals != NULL)
+						{
+							CopyNormal (prototypeNormals, normals, rot, vertexCount, prototypeVerticesSize);
+						}
+						
+						for (int t=0;t<prototypeTrisSize;t++)
+							triangles[t+triangleCount] = prototypeTris[t] + vertexCount;
+												
+						triangleCount += prototypeTrisSize;
+						vertexCount += prototypeVerticesSize;
+					}
+				}
+			}
+		}
+	}
+	PROFILER_END_INTERNAL;
+	
+	PROFILER_BEGIN_INTERNAL(gAssignToMesh, NULL);
+
+	AssertIf(triangleCount != totalTriangleCount);
+	AssertIf(vertexCount != totalVertexCount);
+	
+	// Assign the mesh
+	mesh.Clear(true);
+	unsigned meshFormat = VERTEX_FORMAT5 (Vertex, Normal, Color, TexCoord0, TexCoord1);
+	if (renderMode == kDetailBillboard)
+		meshFormat |= VERTEX_FORMAT1 (Tangent);
+	
+	mesh.ResizeVertices (vertexCount, meshFormat);
+	strided_copy (vertices, vertices + vertexCount, mesh.GetVertexBegin ());
+	strided_copy (colors, colors + vertexCount, mesh.GetColorBegin ());
+	strided_copy (normals, normals + vertexCount, mesh.GetNormalBegin ());
+	strided_copy (uvs, uvs + vertexCount, mesh.GetUvBegin (0));
+	strided_copy (uvs2, uvs2 + vertexCount, mesh.GetUvBegin (1));
+	if (renderMode == kDetailBillboard)
+		strided_copy (tangents, tangents + vertexCount, mesh.GetTangentBegin ());
+
+	mesh.SetIndicesComplex (triangles, triangleCount, 0, kPrimitiveTriangles, Mesh::k16BitIndices);
+	mesh.SetChannelsDirty (mesh.GetAvailableChannels (), true);
+	mesh.RecalculateBounds ();
+	
+	if (renderMode == kDetailBillboard)
+		ExpandDetailBillboardBounds(mesh, detailMaxHalfWidth, detailMaxHeight);
+
+	PROFILER_END_INTERNAL;
+}
+	
+void DetailDatabase::ComputeVertexAndTriangleCount(DetailPatch &patch, DetailRenderMode renderMode, float density, int* vertexCount, int* triangleCount)
+{
+	*triangleCount = 0;
+	*vertexCount = 0;
+	int res = m_PatchSamples;
+
+	for (int i=0;i<patch.layerIndices.size();i++)
+	{
+		DetailPrototype &prototype = m_DetailPrototypes[patch.layerIndices[i]];
+		if (prototype.renderMode != renderMode)
+			continue;
+			
+		if (prototype.vertices.empty()) 
+			continue;
+
+		int count = 0;
+		for (int y=0;y<res;y++)
+		{
+			for (int x=0;x<res;x++)
+			{
+				int nbIndex = y * res + x + i * res * res;
+				int origCount = patch.numberOfObjects[nbIndex];
+				if (!origCount)
+					continue;
+				int newCount = (int)(origCount * density + (kDitherTable[(x&7)*8+(y&7)] - 0.5f) / 64.0f);
+				count += newCount;
+			}
+		}
+
+		
+		
+		// Clamp the number of genrated details to not generate more than kClampedVertex vertices
+		int maxCount = (kClampedVertexCount - *vertexCount) / prototype.vertices.size();
+		count = std::min(maxCount, count);
+		
+		*triangleCount += prototype.triangles.size() * count;
+		*vertexCount += prototype.vertices.size() * count;
+	}
+}
+
+
+void DetailDatabase::UpdateDetailPrototypesIfDirty ()
+{
+	if (m_IsPrototypesDirty)
+		RefreshPrototypes();
+}
+
+#if UNITY_EDITOR
+/*
+AssetDatabase::RegisterPostprocessCallback (Postprocess);
+static void Postprocess (const std::set<UnityGUID>& refreshed, const std::set<UnityGUID>& removed, const std::set<UnityGUID>& moved);
+{
+	for (std::set<UnityGUID>::iterator i=refresh.begin();i != refreshed.end();i++)
+	{
+		PPtr<Texture> tex = dynamic_pptr_cast<Texture*> (GetMainAsset());
+		if (tex)
+		{
+			vector<TerrainData*> data;
+			FindObjectsOfType(data);
+			data.GetDetailDatabase().RefreshPrototypes();
+		}
+	}
+	
+}
+*/
+#endif
+
+
+
+void DetailPrototypeToMono (const DetailPrototype &src, MonoDetailPrototype &dest) {
+	dest.prototype = Scripting::ScriptingWrapperFor (src.prototype);
+	dest.prototypeTexture = Scripting::ScriptingWrapperFor (src.prototypeTexture);
+	dest.healthyColor = src.healthyColor;
+	dest.dryColor = src.dryColor;
+	dest.minWidth = src.minWidth;
+	dest.maxWidth = src.maxWidth;
+	dest.minHeight = src.minHeight;
+	dest.maxHeight = src.maxHeight;
+	dest.noiseSpread = src.noiseSpread;
+	dest.bendFactor = src.bendFactor;
+	dest.renderMode = src.renderMode;
+	dest.usePrototypeMesh = src.usePrototypeMesh;
+	
+}
+void DetailPrototypeToCpp (MonoDetailPrototype &src, DetailPrototype &dest) {
+	dest.prototype = ScriptingObjectToObject<GameObject> (src.prototype);
+	dest.prototypeTexture = ScriptingObjectToObject<Texture2D> (src.prototypeTexture);
+	dest.healthyColor = src.healthyColor;
+	dest.dryColor = src.dryColor;
+	dest.minWidth = src.minWidth;
+	dest.maxWidth = src.maxWidth;
+	dest.minHeight = src.minHeight;
+	dest.maxHeight = src.maxHeight;
+	dest.noiseSpread = src.noiseSpread;
+	dest.bendFactor = src.bendFactor;
+	dest.renderMode = src.renderMode;
+	dest.usePrototypeMesh = src.usePrototypeMesh;
+}
+
+
+#endif // ENABLE_TERRAIN
-- 
cgit v1.1-26-g67d0