+Unity Runtime codeHEADmaster

1 files changed, 600 insertions, 0 deletions

diff --git a/Runtime/Terrain/SplatDatabase.cpp b/Runtime/Terrain/SplatDatabase.cpp
new file mode 100644
index 0000000..41cdf7b
--- /dev/null
+++ b/Runtime/Terrain/SplatDatabase.cpp
@@ -0,0 +1,600 @@
+#include "UnityPrefix.h"
+#include "SplatDatabase.h"
+
+#if ENABLE_TERRAIN
+
+#include "Runtime/Graphics/Texture2D.h"
+#include "Runtime/Math/Color.h"
+#include "Runtime/Graphics/Image.h"
+#include "TerrainData.h"
+#include "Runtime/Scripting/Scripting.h"
+
+#if UNITY_EDITOR
+#include "Editor/Src/AssetPipeline/AssetImporter.h"
+#endif
+
+#define PRINT_BASEMAP_TIME 0
+
+#if PRINT_BASEMAP_TIME
+double GetTimeSinceStartup();
+#endif
+
+
+using namespace std;
+
+SplatPrototype::SplatPrototype ()
+:	tileSize(15, 15),
+	tileOffset(0, 0)
+{	
+	
+}
+
+SplatDatabase::SplatDatabase (TerrainData *owner)
+:	m_BaseMap(NULL)
+,	m_AlphamapResolution(512)
+,	m_BaseMapResolution(512)
+,   m_BaseMapDirty (true)
+{
+	m_TerrainData = owner;
+}
+
+SplatDatabase::~SplatDatabase()
+{
+	if( m_BaseMap )
+		DestroySingleObject( m_BaseMap );
+}
+
+void SplatDatabase::UploadBasemap()
+{
+	if (!m_BaseMap->IsInstanceIDCreated())
+	{
+		Object::AllocateAndAssignInstanceID(m_BaseMap);
+		m_BaseMap->SetHideFlags (Object::kHideAndDontSave);
+		m_BaseMap->SetWrapMode( kTexWrapClamp );
+	}
+	m_BaseMap->AwakeFromLoad(kDefaultAwakeFromLoad);
+}
+
+
+// Typical time spent in recalculate base maps (core duo w/ gcc):
+// 6 splats, basemap size 2048:
+//   0.53 seconds (0.072 getting the mips, 0.031 getting alpha map, 0.268 blending, 0.16 uploading texture)
+// 6 splats, basemap size 1024:
+//   0.21 seconds (0.072 getting the mips, 0.031 getting alpha map, 0.067 blending, 0.04 uploading texture)
+//
+// Here we operate on ColorRGBA32 colors. The first quick implementation used ColorRGBAf,
+// that was about 40% slower.
+
+void SplatDatabase::RecalculateBasemap(bool allowUpload)
+{
+	//
+	// create/resize base map texture
+	
+	int basemapSize = m_BaseMapResolution;
+	if( !m_BaseMap )
+	{
+		m_BaseMap = NEW_OBJECT_FULL (Texture2D, kCreateObjectFromNonMainThread);
+		m_BaseMap->Reset();
+
+		// 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_BaseMap->HackSetAwakeDidLoadThreadedWasCalled();
+		
+		// uncomment this for proper handling (but assert will fire in current impl)
+		//m_BaseMap->AwakeFromLoad(kDidLoadThreaded);
+
+		m_BaseMap->InitTexture( basemapSize, basemapSize, kTexFormatRGBA32, Texture2D::kMipmapMask | Texture2D::kThreadedInitialize, 1 );
+		
+		// uncomment this for proper handling (but you will upload texture twice in current impl)
+		//m_BaseMap->AwakeFromLoad(kDidLoadThreaded);
+	}
+	else
+	{
+		if( m_BaseMap->GetDataWidth() != basemapSize || m_BaseMap->GetDataHeight() != basemapSize || m_BaseMap->GetTextureFormat() != kTexFormatRGBA32 || !m_BaseMap->HasMipMap() )
+			m_BaseMap->ResizeWithFormat (basemapSize, basemapSize, kTexFormatRGBA32, Texture2D::kMipmapMask);
+	}
+	
+	Vector3f terrainSize = m_TerrainData->GetHeightmap().GetSize();
+
+	#if PRINT_BASEMAP_TIME
+	double t0 = GetTimeSinceStartup();
+	#endif
+	
+	#define SPLAT_FIX_BITS 16	// use 16.16 fixed point
+	
+	// Note to optimizers: separating this struct into hot (x,y,yoffset) & cold (the rest) data
+	// actually made it slower (about 20%, core duo w/ gcc), due to more housekeeping in the
+	// innermost loop.
+	struct SplatData
+	{
+		int xmask;	// 16.16 fixed point
+		int ymask;	// 16.16 fixed point
+		int dx;		// 16.16 fixed point
+		int dy;		// 16.16 fixed point
+		int x;		// 16.16 fixed point
+		int y;		// 16.16 fixed point
+		int xoffset;// 16.16 fixed point
+		int yoffset;
+		int width;
+		ColorRGBA32* mip;
+	};
+
+	
+	//
+	// Get data needed from the splat textures.
+	// This gets the optimal mip level in RGBA32 colors, and computes step sizes etc.
+	
+	int splatCount = m_Splats.size();
+	
+	SplatData* splatData = new SplatData[splatCount];
+	
+	// Set up sRGB state for splat maps
+	bool sRGBEncountered = false;
+	for( int i = 0; i < splatCount; ++i )
+	{
+		// figure out which mip level of the splat map to use
+		Texture2D* splatTex = dynamic_pptr_cast<Texture2D*> (InstanceIDToObjectThreadSafe(m_Splats[i].texture.GetInstanceID()));
+		if( !splatTex )
+		{
+			// if no splat texture, fill in a dummy one white pixel
+			ErrorStringObject( Format ("Terrain splat %d is null.", i), m_TerrainData );
+			splatData[i].mip = new ColorRGBA32[1];
+			splatData[i].mip[0] = 0xFFFFFFFF;
+			splatData[i].width = 1;
+			splatData[i].xmask = 0;
+			splatData[i].ymask = 0;
+			splatData[i].dx = 0;
+			splatData[i].dy = 0;
+			splatData[i].x = 0;
+			splatData[i].y = 0;
+			continue;
+		}
+
+		if (splatTex->GetStoredColorSpace () != kTexColorSpaceLinear)
+			sRGBEncountered = true;
+
+		#if !UNITY_EDITOR
+		AssertIf(!splatTex->GetIsReadable());
+		#endif
+		int splatWidth = splatTex->GetDataWidth();
+		int splatHeight = splatTex->GetDataHeight();
+		float tilesX = terrainSize.x / m_Splats[i].tileSize.x;
+		float tilesY = terrainSize.z / m_Splats[i].tileSize.y;
+		int splatBaseWidth = std::max( (int)(basemapSize / tilesX), 1 );
+		int splatBaseHeight = std::max( (int)(basemapSize / tilesY), 1 );
+		float areaRatio = (splatWidth * splatHeight) / (splatBaseWidth * splatBaseHeight);
+
+		const float tileOffsetX = m_Splats[i].tileOffset.x / terrainSize.x * tilesX;
+		const float tileOffsetY = m_Splats[i].tileOffset.y / terrainSize.z * tilesY;
+		
+		int mipLevel = int(0.5f * Log2( areaRatio ));
+		mipLevel = clamp( mipLevel, 0, splatTex->CountDataMipmaps() - 1);
+		
+		// get the pixels of this mip level
+		int minSplatSize = GetMinimumTextureMipSizeForFormat( splatTex->GetTextureFormat() );
+		int width = std::max( splatWidth >> mipLevel, minSplatSize );
+		int height = std::max( splatHeight >> mipLevel, minSplatSize );
+		splatData[i].mip = new ColorRGBA32[width * height];
+		if( !splatTex->GetPixels32( mipLevel, splatData[i].mip ) )
+		{
+			memset( splatData[i].mip, 0, width*height*sizeof(ColorRGBA32) );
+			ErrorStringObject( "Failed to get pixels of splat texture", m_TerrainData );
+		}
+		
+		// compute step sizes for this splat
+		splatData[i].width = width;
+		splatData[i].xmask = (width << SPLAT_FIX_BITS) - 1;
+		splatData[i].ymask = (height << SPLAT_FIX_BITS) - 1;
+		float dx = tilesX * width / basemapSize;
+		splatData[i].dx = (int)( dx * (1<<SPLAT_FIX_BITS) );
+		float dy = tilesY * height / basemapSize;
+		splatData[i].dy = (int)( dy * (1<<SPLAT_FIX_BITS) );
+		splatData[i].xoffset	= (int)(tileOffsetX * width * (1<<SPLAT_FIX_BITS));
+		int yoffset				= (int)(tileOffsetY * height * (1<<SPLAT_FIX_BITS));
+		splatData[i].x = 0;
+		splatData[i].y = yoffset + (splatData[i].dy / 2) & splatData[i].ymask; // start at mid-pixel
+	}
+
+	if (sRGBEncountered)
+		m_BaseMap->SetStoredColorSpaceNoDirtyNoApply (kTexColorSpaceSRGB);
+	else
+		m_BaseMap->SetStoredColorSpaceNoDirtyNoApply (kTexColorSpaceLinear);
+	
+	#if PRINT_BASEMAP_TIME
+	double t1 = GetTimeSinceStartup();
+	#endif
+	
+	//
+	// get alpha map
+	
+	dynamic_array<UInt8> alphamap;
+	GetAlphamaps( alphamap );
+
+	#if PRINT_BASEMAP_TIME
+	double t2 = GetTimeSinceStartup();
+	#endif
+	
+	//
+	// blend splats directly into texture data
+	
+	AssertIf( m_BaseMap->GetTextureFormat() != kTexFormatRGBA32 );
+	ColorRGBA32* pix = reinterpret_cast<ColorRGBA32*>( m_BaseMap->GetRawImageData() );
+	
+	int alphaFixStep = (m_AlphamapResolution << SPLAT_FIX_BITS) / basemapSize; // 16.16 fixed point
+	int alphaFixY = 0;
+	int pixIndex = 0;
+	for( int y = 0; y < basemapSize; ++y, alphaFixY += alphaFixStep )
+	{
+		int alphaY = (alphaFixY >> SPLAT_FIX_BITS);
+		int alphaYIndex = alphaY * m_AlphamapResolution * splatCount;
+		
+		int alphaFixX = 0;
+		for( int s = 0; s < splatCount; ++s ) {
+			splatData[s].x = (splatData[s].dx / 2 + splatData[s].xoffset) & splatData[s].xmask;
+			splatData[s].yoffset = (splatData[s].y >> SPLAT_FIX_BITS) * splatData[s].width;
+		}
+		for( int x = 0; x < basemapSize; ++x, alphaFixX += alphaFixStep, ++pixIndex )
+		{
+			int alphaX = (alphaFixX >> SPLAT_FIX_BITS);
+			int alphaXIndex = alphaX * splatCount;
+			
+			// Per-pixel loop: accumulate splat textures into final color.
+			// No need for pixel clipping since alphamap weights are always normalized.
+			UInt32 c = 0;
+			for( int s = 0; s < splatCount; ++s )
+			{
+				SplatData& splat = splatData[s];
+				ColorRGBA32 splatCol = splat.mip[ splat.yoffset + (splat.x >> SPLAT_FIX_BITS) ];
+				
+				// Note for optimizers: trying to get rid of multiplies in color*byte by using
+				// a 256x256 lookup table is about 2x slower (core duo w/ gcc).
+				
+				// We always have to set alpha to zero. Using color * byte and then setting
+				// alpha to zero does not get optimized away by gcc, so use directly changed code
+				// from color * byte.
+				int scale = alphamap[alphaYIndex + alphaXIndex + s];
+				const UInt32& u = reinterpret_cast<const UInt32&> (splatCol);
+				#if UNITY_LITTLE_ENDIAN
+				UInt32 lsb = (((u & 0x00ff00ff) * scale) >> 8) & 0x00ff00ff;
+				UInt32 msb = (((u & 0xff00ff00) >> 8) * scale) & 0x0000ff00;
+				#else
+				UInt32 lsb = (((u & 0x00ff00ff) * scale) >> 8) & 0x00ff0000;
+				UInt32 msb = (((u & 0xff00ff00) >> 8) * scale) & 0xff00ff00;
+				#endif
+				c += lsb | msb;
+				
+				splat.x = (splat.x + splat.dx) & splat.xmask; // next splat texel
+			}
+			pix[pixIndex] = ColorRGBA32(c);
+			
+		}
+		for( int s = 0; s < splatCount; ++s )
+			splatData[s].y = (splatData[s].y + splatData[s].dy) & splatData[s].ymask;
+	}
+	
+	if (splatCount == 0)
+	{
+		memset(pix, 0xFFFFFFFF, basemapSize * basemapSize * GetBytesFromTextureFormat(m_BaseMap->GetTextureFormat()));
+	}
+	
+	#if PRINT_BASEMAP_TIME
+	double t3 = GetTimeSinceStartup();
+	#endif
+
+	m_BaseMap->RebuildMipMap();
+	
+	// Upload base map texture
+
+	if(allowUpload)
+		UploadBasemap();	
+		
+	// Cleanup
+	for( int i = 0; i < splatCount; ++i )
+		delete[] splatData[i].mip;
+	delete[] splatData;
+	
+	#if PRINT_BASEMAP_TIME
+	double t4 = GetTimeSinceStartup();
+	printf_console( "basemap time calc: %.2f (%.3f mips, %.3f alpha, %.3f blend, %.2f upload)\n", (t4-t0), (t1-t0), (t2-t1), (t3-t2), (t4-t3) );
+	#endif
+	m_BaseMapDirty = false;
+}
+
+
+void SplatDatabase::GetAlphamaps (int xBase, int yBase, int width, int height, float* buffer)
+{
+	int layers = GetDepth();
+
+	ColorRGBAf *tempBuffer;
+	ALLOC_TEMP(tempBuffer, ColorRGBAf, width * height);
+
+
+	for (int m=0;m<m_AlphaTextures.size();m++)
+	{
+		int componentCount = min(layers - m * 4, 4);
+		
+		Texture2D* texture = m_AlphaTextures[m];
+		if (texture) {
+			texture->GetPixels (xBase, yBase, width, height, 0, tempBuffer);
+		} else {
+			ErrorStringObject (Format ("splatdatabase alphamap %d is null", m), m_TerrainData);
+			memset (tempBuffer, 0, width * height * sizeof(ColorRGBAf));
+		}
+		
+		for (int y=0;y<height;y++)
+		{
+			for (int x=0;x<width;x++)
+			{
+				float *pixel = reinterpret_cast<float*> (&tempBuffer[y*width+x]);
+				for (int a=0;a<componentCount;a++) {
+					int layer = m * 4+a;
+					buffer[y * width * layers + x * layers + layer] = pixel[a];
+				}
+			}
+		}
+	}
+}
+
+void SplatDatabase::GetAlphamaps( dynamic_array<UInt8>& buffer )
+{
+	// resync the m_AlphamapResolution with textures in m_AlphaTextures array
+	for (int m = 0; m < m_AlphaTextures.size(); ++m)
+	{
+		Texture2D* texture = dynamic_pptr_cast<Texture2D*>(InstanceIDToObjectThreadSafe(m_AlphaTextures[m].GetInstanceID()));
+		if (texture == NULL)
+		{
+			ErrorStringObject(Format("splatdatabase alphamap %d is null", m), m_TerrainData);
+			continue;
+		}
+
+		if (texture->GetDataWidth() != m_AlphamapResolution)
+		{
+			if (m == 0)
+			{
+				WarningStringObject(Format("splatdatabase alphamap %d texture size doesn't match alphamap resolution setting: please resave the terrain asset.", m), m_TerrainData);
+				m_AlphamapResolution = texture->GetDataWidth();
+			}
+			else
+			{
+				ErrorStringObject(Format("splatdatabase alphamap %d texture size doesn't match to other alphamap textures.", m), m_TerrainData);
+			}
+		}
+	}
+
+	int size = m_AlphamapResolution;
+	int pixelCount = size * size;
+	int layers = GetDepth();
+
+	buffer.resize_uninitialized( size * size * layers );
+	
+	ColorRGBA32 *tempBuffer;
+	ALLOC_TEMP(tempBuffer, ColorRGBA32, size * size);
+	
+	for( int m=0;m<m_AlphaTextures.size();m++ )
+	{
+		int componentCount = min(layers - m * 4, 4);
+		
+		Texture2D* texture = dynamic_pptr_cast<Texture2D*>(InstanceIDToObjectThreadSafe(m_AlphaTextures[m].GetInstanceID()));
+		if (texture != NULL && texture->GetDataWidth() == size && texture->GetDataHeight() == size)
+		{
+			texture->GetPixels32( 0, tempBuffer );
+		}
+		else
+		{
+			ErrorStringObject (Format ("splatdatabase alphamap %d is invalid", m), m_TerrainData);
+			memset (tempBuffer, 0, pixelCount * sizeof(ColorRGBA32));
+		}
+
+		int bufferIndex = m * 4;
+		for( int i = 0; i < pixelCount; ++i )
+		{
+			UInt8* pixel = reinterpret_cast<UInt8*>( &tempBuffer[i] );
+			for( int a = 0; a < componentCount; a++ )
+			{
+				buffer[bufferIndex + a] = pixel[a];
+			}
+			bufferIndex += layers;
+		}
+	}
+}
+
+
+/// Assign back the alpha map in the given area
+void SplatDatabase::SetAlphamaps (int xBase, int yBase, int width, int height, float* buffer)
+{
+	int layers = GetDepth ();
+
+	ColorRGBAf *tempBuffer;
+	ALLOC_TEMP(tempBuffer, ColorRGBAf, width * height);
+	int alphamaps = m_AlphaTextures.size();
+	for (int m=0; m < alphamaps; m++)
+	{
+		memset (tempBuffer, 0, width * height* sizeof (ColorRGBAf)); 
+		int componentCount = min(layers - m * 4, 4);
+
+		for (int y=0;y<height;y++)
+		{
+			for (int x=0;x<width;x++)
+			{
+				float *pixel = reinterpret_cast<float*> (&tempBuffer[y*width+x]);
+				for (int a=0; a<componentCount; a++) {
+					int layer = m * 4 + a;
+					pixel[a] = buffer[y * width * layers + x * layers + layer];
+				
+				}
+			}
+		}
+		Texture2D* texture = m_AlphaTextures[m];
+		if (!texture) {
+			ErrorStringObject (Format ("splatdatabase alphamap %d is null", m), m_TerrainData);
+			continue;
+		}
+		
+		texture->SetPixels(xBase, yBase, width, height, width * height, tempBuffer, 0 );
+		texture->UpdateImageData();
+	}
+	m_BaseMapDirty = true;
+}
+
+static void ClearAlphaMap (Texture2D * map, const ColorRGBAf &color)
+{
+	ImageReference image;
+	if( !map->GetWriteImageReference(&image, 0, 0) )
+	{
+		ErrorString("Unable to retrieve image reference");
+		return;
+	}
+		
+	ColorRGBA32 tempColor (color);
+	ColorRGBA32 colorARGB (tempColor.a, tempColor.r, tempColor.g, tempColor.b);
+
+	int texWidth = image.GetWidth();
+	int texHeight = image.GetHeight();
+	for( int iy = 0; iy < texHeight; ++iy )
+	{
+		ColorRGBA32* pixel = (ColorRGBA32*)image.GetRowPtr(iy);
+		for( int ix = 0; ix < texWidth; ++ix )
+		{
+			*pixel = colorARGB;
+			++pixel;
+		}
+	}
+	map->UpdateImageData();
+}
+
+
+Texture2D *SplatDatabase::AllocateAlphamap (const ColorRGBAf &color)
+{
+	Texture2D* map = CreateObjectFromCode<Texture2D>(kDefaultAwakeFromLoad);
+	map->ResizeWithFormat(m_AlphamapResolution, m_AlphamapResolution, kTexFormatARGB32, Texture2D::kMipmapMask);
+	map->SetWrapMode (kTexWrapClamp);
+	
+	ClearAlphaMap(map, color);
+	
+	map->SetName(Format ("SplatAlpha %u", (int)m_AlphaTextures.size()).c_str ());
+	#if UNITY_EDITOR
+	if (m_TerrainData->IsPersistent ())
+		AddAssetToSameFile (*map, *m_TerrainData);
+	#endif
+	return map;
+}
+
+void SplatDatabase::AwakeFromLoad (AwakeFromLoadMode mode)
+{
+	if ((mode & kDidLoadThreaded) == 0)
+	{
+		// Ensure that the alpha map textures are allocated properly.
+		// When removing some splat texture, that can cause an alpha map to be destroyed.
+		// If later the removal is undone, we need to recreate the alpha map texture again.
+		int splatCount = m_Splats.size();
+		int required = (splatCount / 4) + ((splatCount % 4) != 0 ? 1 : 0);
+		AssertIf( m_AlphaTextures.size() != required );
+		for( int i = 0; i < required; ++i )
+		{
+			Texture2D* tex = m_AlphaTextures[i];
+			if( tex == NULL )
+			{
+				ColorRGBAf color = ColorRGBAf (0,0,0,0);
+				if( i == 0 )
+					color.r = 1.0f;
+				m_AlphaTextures[i] = AllocateAlphamap (color);
+			}
+		}
+		
+		m_BaseMapDirty = true;
+	}
+}
+
+
+void SplatDatabase::Init (int alphamapResolution, int basemapResolution)
+{
+	m_AlphamapResolution = alphamapResolution;
+	m_BaseMapResolution = basemapResolution;
+}
+
+void SplatDatabase::SetAlphamapResolution (int res)
+{
+	m_AlphamapResolution = clamp( res, 16, 2048 );
+	for (int i=0;i<m_AlphaTextures.size();i++)
+	{
+		Texture2D* map = m_AlphaTextures[i];
+		if (map)
+		{
+			map->ResizeWithFormat(m_AlphamapResolution, m_AlphamapResolution, kTexFormatARGB32, Texture2D::kMipmapMask);
+			ClearAlphaMap(map, i == 0 ? ColorRGBAf (1, 0, 0, 0) : ColorRGBAf (0, 0, 0, 0));
+		}
+	}
+	RecalculateBasemap(true);
+}
+
+void SplatDatabase::SetBaseMapResolution( int res )
+{
+	m_BaseMapResolution = clamp( res, 16, 2048 );
+	RecalculateBasemap(true);
+}
+
+bool SplatDatabase::RecalculateBasemapIfDirty()
+{
+	if (m_BaseMapDirty)
+	{
+		RecalculateBasemap(true);
+		return true;
+	}
+	return false;
+}
+		
+void SplatDatabase::SetSplatPrototypes (const vector<SplatPrototype> &splats )
+{
+	// TODO: TEST for adding & removing
+	// TODO: renormalize & optionally ditch an alphatexture when removing one
+	// Do we need another one
+	int required = (splats.size() / 4) + ((splats.size() % 4) != 0 ? 1 : 0);
+	if (m_AlphaTextures.size() < required)
+	{
+		for (int i = m_AlphaTextures.size(); i < required; i++)
+		{
+			ColorRGBAf color = ColorRGBAf (0,0,0,0);
+			if (m_AlphaTextures.empty ())
+				color.r = 1;
+			m_AlphaTextures.push_back (AllocateAlphamap (color));
+		}
+	}
+	else if ( m_AlphaTextures.size() > required)
+	{
+		for (int i = required; i < m_AlphaTextures.size(); i++)
+		{
+			DestroySingleObject(m_AlphaTextures[i]);
+		}
+		m_AlphaTextures.resize (required);
+	}
+	m_Splats = splats;
+	RecalculateBasemap(true);
+	m_TerrainData->SetDirty();
+}
+
+Texture2D * SplatDatabase::GetAlphaTexture (int index)
+{
+	return m_AlphaTextures[index];
+}
+
+Texture2D* SplatDatabase::GetBasemap()
+{
+	return m_BaseMap;
+}
+
+
+void SplatPrototypeToMono (const SplatPrototype &src, MonoSplatPrototype &dest) {
+	dest.texture = Scripting::ScriptingWrapperFor (src.texture);
+	dest.normalMap = Scripting::ScriptingWrapperFor (src.normalMap);
+	dest.tileSize = src.tileSize;
+	dest.tileOffset = src.tileOffset;
+}
+void SplatPrototypeToCpp (MonoSplatPrototype &src, SplatPrototype &dest) {
+	dest.texture = ScriptingObjectToObject<Texture2D> (src.texture);
+	dest.normalMap = ScriptingObjectToObject<Texture2D> (src.normalMap);
+	dest.tileSize = src.tileSize;
+	dest.tileOffset = src.tileOffset;
+}
+
+
+#endif // ENABLE_TERRAIN