+Unity Runtime codeHEADmaster

1 files changed, 633 insertions, 0 deletions

diff --git a/Runtime/GfxDevice/opengles20/TexturesGLES20.cpp b/Runtime/GfxDevice/opengles20/TexturesGLES20.cpp
new file mode 100644
index 0000000..b300e85
--- /dev/null
+++ b/Runtime/GfxDevice/opengles20/TexturesGLES20.cpp
@@ -0,0 +1,633 @@
+#include "UnityPrefix.h"
+#include "TexturesGLES20.h"
+#include "Runtime/GfxDevice/GfxDeviceTypes.h"
+#include "Runtime/Graphics/Image.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/GfxDevice/TextureUploadUtils.h"
+#include "Runtime/Graphics/S3Decompression.h"
+#include "Runtime/Graphics/Texture2D.h"
+#include "Runtime/Shaders/GraphicsCaps.h"
+#include "Runtime/Utilities/BitUtility.h"
+#include "IncludesGLES20.h"
+#include "AssertGLES20.h"
+#include "DebugGLES20.h"
+#include "TextureIdMapGLES20.h"
+
+
+#if GFX_SUPPORTS_OPENGLES20
+
+// these are used to fill in table without using too much width
+#define GL_ETC1			GL_ETC1_RGB8_OES
+#define GL_DXT1			GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+#define GL_DXT3			GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
+#define GL_DXT5			GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+#define GL_SRGBDXT1		GL_COMPRESSED_SRGB_S3TC_DXT1_NV
+#define GL_SRGBDXT3		GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV
+#define GL_SRGBDXT5		GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV
+#define GL_PVR1RGB2		GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG
+#define GL_PVR1RGBA2	GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
+#define GL_PVR1RGB4		GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+#define GL_PVR1RGBA4	GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+#define GL_ATC4			GL_ATC_RGB_AMD
+#define GL_ATC8			GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD
+
+#define RESERVED_FORMAT	-1,-1,-1,0,
+
+const static int kTextureFormatTable[kTexFormatTotalCount*4] =
+{
+	// for GLES format == internal format, so we keep only one
+	// format, 		srgb format, 		datatype, 						alternative format
+	0,				0,					0,								0,
+	GL_ALPHA,		GL_ALPHA,			GL_UNSIGNED_BYTE,				0,					// Alpha8
+	GL_RGBA,		GL_RGBA,			GL_UNSIGNED_SHORT_4_4_4_4,		0,					// ARGB4444
+	GL_RGB,			GL_SRGB_EXT,		GL_UNSIGNED_BYTE,				0,					// RGB24
+	GL_RGBA,		GL_SRGB_ALPHA_EXT,	GL_UNSIGNED_BYTE,				0,					// RGBA32
+	-1,				-1,					-1,								kTexFormatRGBA32,	// ARGB32
+	GL_RGBA,		GL_SRGB_ALPHA_EXT,	GL_HALF_FLOAT_OES,				kTexFormatRGBA32,	// ARGBFloat
+	GL_RGB,			GL_RGB,				GL_UNSIGNED_SHORT_5_6_5,		0,					// RGB565
+	-1,				-1,					-1,								kTexFormatRGB24,	// BGR24
+	-1,				-1,					-1,								kTexFormatAlpha8,	// AlphaLum16
+	GL_DXT1,		GL_SRGBDXT1,		-1,								0,					// DXT1
+	GL_DXT3,		GL_SRGBDXT3,		-1,								0,					// DXT3
+	GL_DXT5,		GL_SRGBDXT5,		-1,								0,					// DXT5
+	GL_RGBA,		GL_RGBA,			GL_UNSIGNED_SHORT_4_4_4_4,		0,					// RGBA4444
+
+	RESERVED_FORMAT /*14*/	RESERVED_FORMAT /*15*/	RESERVED_FORMAT /*16*/	RESERVED_FORMAT /*17*/
+	RESERVED_FORMAT /*18*/ 	RESERVED_FORMAT /*19*/	RESERVED_FORMAT /*20*/	RESERVED_FORMAT /*21*/
+	RESERVED_FORMAT /*22*/	RESERVED_FORMAT /*23*/	RESERVED_FORMAT /*24*/	RESERVED_FORMAT /*25*/
+	RESERVED_FORMAT /*26*/	RESERVED_FORMAT /*27*/ 	RESERVED_FORMAT /*28*/	RESERVED_FORMAT /*29*/
+
+	GL_PVR1RGB2,	-1,					-1,								0,					// PVRTC_RGB2
+	GL_PVR1RGBA2,	-1,					-1,								0,					// PVRTC_RGBA2
+	GL_PVR1RGB4,	-1,					-1,								0,					// PVRTC_RGB4
+	GL_PVR1RGBA4,	-1,					-1,								0,					// PVRTC_RGBA4
+	GL_ETC1,		-1,					-1,								0,					// ETC_RGB4
+	GL_ATC4,		-1,					-1,								0,					// ATC_RGB4
+	GL_ATC8,		-1,					-1,								0,					// ATC_RGBA8
+	GL_BGRA_EXT,	GL_BGRA_EXT,		GL_UNSIGNED_BYTE,				0,					// BGRA32
+};
+
+#undef GL_ETC1
+#undef GL_DXT1
+#undef GL_DXT3
+#undef GL_DXT5
+#undef GL_PVR1RGB2
+#undef GL_PVR1RGBA2
+#undef GL_PVR1RGB4
+#undef GL_PVR1RGBA4
+#undef GL_ATC4
+#undef GL_ATC8
+#undef RESERVED_FORMAT
+
+
+static int IsSupportedTextureFormat(TextureFormat inFormat)
+{
+	return (kTextureFormatTable[inFormat*4+0] > 0) && gGraphicsCaps.supportsTextureFormat[inFormat];
+}
+
+static int RemapToAlternativeFormat (TextureFormat inFormat)
+{
+	int altFormat = kTextureFormatTable[inFormat*4+3];
+	return altFormat > 0 ? altFormat : kTexFormatRGBA32;
+}
+
+static void GetUncompressedTextureFormat (int inFormat, bool srgb, int* format, int* dataType)
+{
+	DebugAssertIf( IsAnyCompressedTextureFormat(inFormat) );
+	*format   = kTextureFormatTable[inFormat*4 + (srgb?1:0)];
+	*dataType = kTextureFormatTable[inFormat*4 + 2];
+}
+
+static void GetCompressedTextureFormat (int inFormat, bool srgb, int width, int height, int* internalFormat, int* size)
+{
+	// srgb support will be enabled only if compressed srgb is supported
+	// also we will ever use only supported formats
+	*internalFormat = kTextureFormatTable[inFormat*4 + (srgb?1:0)];
+	Assert(*internalFormat != -1);
+
+	switch(inFormat)
+	{
+	case kTexFormatPVRTC_RGB4:
+	case kTexFormatPVRTC_RGBA4:
+		*size = (std::max(width, 8) * std::max(height, 8) * 4 + 7) / 8;
+		break;
+	case kTexFormatPVRTC_RGB2:
+	case kTexFormatPVRTC_RGBA2:
+		*size =  (std::max(width, 16) * std::max(height, 8) * 2 + 7) / 8;
+		break;
+	case kTexFormatDXT1:
+	case kTexFormatATC_RGB4:
+		*size = ((width + 3) / 4) * ((height + 3) / 4) * 8;
+		break;
+	case kTexFormatDXT5:
+	case kTexFormatATC_RGBA8:
+		*size = ((width + 3) / 4) * ((height + 3) / 4) * 16;
+		break;
+	case kTexFormatETC_RGB4:
+		*size = 8 * ((width+3)>>2) * ((height+3)>>2); // 8 bytes per 4x4 block
+		break;
+	default:
+		Assert(false && "Texture is not compressed");
+	}
+}
+
+static TextureFormat GetUploadFormat(TextureFormat format, bool& uploadIsCompressed, bool& decompressOnTheFly)
+{
+	TextureFormat uploadFormat = format;
+	uploadIsCompressed = IsAnyCompressedTextureFormat(format);
+	decompressOnTheFly = false;
+	if (!IsSupportedTextureFormat(format))
+	{
+		if( uploadIsCompressed )
+		{
+			uploadIsCompressed = false;
+			decompressOnTheFly = true;
+		}
+
+		uploadFormat = RemapToAlternativeFormat(format);
+	}
+
+	if( decompressOnTheFly )
+	{
+		if (IsCompressedPVRTCTextureFormat(format))
+		{
+			printf_console ("WARNING: PVRTC texture format is not supported, decompressing texture\n");
+		}
+		else if (IsCompressedDXTTextureFormat(format))
+		{
+			printf_console ("WARNING: DXT texture format is not supported, decompressing texture\n");
+		}
+		else if (IsCompressedETCTextureFormat(format))
+		{
+			printf_console ("WARNING: ETC texture format is not supported, decompressing texture\n");
+		}
+		else if (IsCompressedATCTextureFormat(format))
+		{
+			printf_console ("WARNING: ATC texture format is not supported, decompressing texture\n");
+		}
+	}
+
+	return uploadFormat;
+}
+
+#if UNITY_PEPPER
+// Unity generates textures as ARGB4444, but GLES only supports RGBA4444.
+// On mobile GLES, we swizzle textures at build time, but on NaCl, we use the same data format as used
+// in the normal web player, so we cannot do that here. So we swizzle at runtime.
+// TODO for 4.0: See if there is any good reason to use ARGB4444 at all, or if we should switch to RGBA4444 completely!
+UInt8 *SwizzleRGBA4444 (UInt8 *srcData, UInt8 **decompressBuffer, int width, int height)
+{
+	if( *decompressBuffer == NULL )
+		*decompressBuffer = new UInt8[width * height * 2];
+
+	UInt8 *feedData = *decompressBuffer;
+	for (int q = 0; q < width * height; ++q)
+	{
+		// RGBA4444 <- ARGB4444
+		UInt32 argb = *(UInt16*)(srcData + q * 2);
+		UInt16 rgba = (argb << 4) | (0x0F & (argb >> 12));
+
+		feedData[q * 2 + 0] = (UInt8)rgba;
+		feedData[q * 2 + 1] = (UInt8)(rgba >> 8);
+	}
+	return feedData;
+}
+#endif
+
+void UploadTexture2DGLES2(
+	TextureID tid, TextureDimension dimension, UInt8* srcData, int width, int height,
+	TextureFormat format, int mipCount, UInt32 uploadFlags, int masterTextureLimit, TextureColorSpace colorSpace )
+{
+	Assert( srcData != NULL );
+	AssertIf( (!IsPowerOfTwo(width) || !IsPowerOfTwo(height)) && !IsNPOTTextureAllowed(mipCount > 1) );
+	if( dimension != kTexDim2D )
+	{
+		ErrorStringMsg( "Incorrect texture dimension! (dimension = %d)", dimension );
+		return;
+	}
+
+	bool uploadIsCompressed, decompressOnTheFly;
+	TextureFormat uploadFormat = GetUploadFormat(format, uploadIsCompressed, decompressOnTheFly);
+
+	DBG_TEXTURE_VERBOSE_GLES20("Texture2D #%i (%ix%i) unityFmt: %d, uploadFmt: %d, compressed: %d, decompressOnCpu: %d",
+							   tid.m_ID, width, height, format, uploadFormat, (int)uploadIsCompressed, (int)decompressOnTheFly);
+	REGISTER_EXTERNAL_GFX_DEALLOCATION(tid.m_ID);
+
+	TextureIdMapGLES20_QueryOrCreate(tid);
+	GetRealGfxDevice().SetTexture (kShaderFragment, 0, 0, tid, dimension, std::numeric_limits<float>::infinity());
+	GLES_CHK(glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
+
+	int maxLevel = mipCount - 1;
+	int baseLevel = std::min( masterTextureLimit, maxLevel );
+
+#if UNITY_IPHONE && GL_APPLE_texture_max_level
+	if( gGraphicsCaps.hasMipMaxLevel )
+	{
+		GLES_CHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL_APPLE, maxLevel));
+	}
+#endif
+
+	// xenon, for real?
+	bool isSRGB = (colorSpace == kTexColorSpaceSRGBXenon || colorSpace == kTexColorSpaceSRGB);
+
+	UInt8* decompressBuffer = NULL;
+	int glesFormat, datatype;
+	int uploadedSize = 0;
+	int skippedMipCount = 0;
+	for( int level = 0; level <= maxLevel; ++level )
+	{
+		UInt8* feedData;
+		int uploadLevel = level - baseLevel - skippedMipCount;
+
+		// Should this level be skipped because of master texture limit?
+		if( level < baseLevel )
+		{
+			feedData = NULL;
+		}
+		// Should this level be skipped because it is too large for hardware limits?
+		else if (width > gGraphicsCaps.maxTextureSize || height > gGraphicsCaps.maxTextureSize)
+		{
+			skippedMipCount++;
+			DBG_TEXTURE_VERBOSE_GLES20("Texture2D #%i mip level %i (%ix%i) is too big, skipping!", tid.m_ID, level, width, height);
+			feedData = NULL;
+		}
+		// Allocate temporary memory and decompress texture
+		else if( decompressOnTheFly )
+		{
+			Assert(uploadFormat == kTexFormatRGBA32);
+
+			int dstWidth = std::max( width, 4 );
+			int dstHeight = std::max( height, 4 );
+			int decompressedSize = CalculateImageSize( dstWidth, dstHeight, uploadFormat );
+			if( decompressBuffer == NULL )
+				decompressBuffer = new UInt8[decompressedSize];
+			feedData = decompressBuffer;
+			DecompressNativeTextureFormat ( format, width, height, (UInt32*)srcData, dstWidth, dstHeight, (UInt32*)feedData );
+
+			if (UNITY_IPHONE && (format == kTexFormatDXT3 || format == kTexFormatDXT5))
+			{
+				printf_console ("swapping DXT channels\n");
+
+				for (int q = 0; q < width * height; ++q)
+				{
+					std::swap(feedData[q * 4 + 0], feedData[q * 4 + 3]);
+					std::swap(feedData[q * 4 + 1], feedData[q * 4 + 2]);
+				}
+			}
+		}
+		// Allocate temporary memory and swizzle texture
+		else if (uploadFormat != format)
+		{
+			int decompressedSize = CalculateImageSize (width, height, uploadFormat);
+			if (decompressBuffer == NULL)
+				decompressBuffer = new UInt8[decompressedSize];
+			feedData = decompressBuffer;
+
+			ImageReference src (width, height, GetRowBytesFromWidthAndFormat (width, format), format, srcData);
+			ImageReference dst (width, height, GetRowBytesFromWidthAndFormat (width, uploadFormat), uploadFormat, feedData);
+			dst.BlitImage( src );
+		}
+#if UNITY_PEPPER
+		else if (uploadFormat == kTexFormatARGB4444)
+		{
+			feedData = SwizzleRGBA4444 (srcData, &decompressBuffer, width, height);
+		}
+#endif
+		else
+		{
+			// Just feed the data
+			feedData = srcData;
+		}
+
+		// If this level should be skipped, just do nothing
+		if( feedData == NULL )
+		{
+		}
+		else
+		{
+			if (uploadIsCompressed)
+			{
+				int size;
+				GetCompressedTextureFormat (uploadFormat, isSRGB, width, height, &glesFormat, &size);
+				if( glesFormat <= 0 )
+				{
+					ErrorString(Format("Format not supported: %u!", (unsigned)uploadFormat));
+					return;
+				}
+
+				DBG_TEXTURE_VERBOSE_GLES20("GLESDebug texture: glCompressedTexImage2D: level=%i fmt=%i width=%i height=%i type=%i data=%x",
+										   uploadLevel, glesFormat, width, height, datatype, (UInt32)feedData);
+				GLES_CHK(glCompressedTexImage2D (GL_TEXTURE_2D, uploadLevel, glesFormat, width, height, 0, size, feedData));
+			}
+			else
+			{
+				GetUncompressedTextureFormat (uploadFormat, isSRGB, &glesFormat, &datatype);
+				if( glesFormat <= 0 )
+				{
+					ErrorString(Format("Format not supported: %u!", (unsigned)uploadFormat));
+					return;
+				}
+
+				int internalFormat = glesFormat;
+			#if UNITY_IPHONE
+				//APPLE_texture_format_BGRA8888 dictates internal format for GL_BGRA_EXT to be GL_RGBA
+				if(glesFormat == GL_BGRA_EXT)
+					internalFormat = GL_RGBA;
+			#endif
+
+				DBG_TEXTURE_VERBOSE_GLES20("GLESDebug texture: glTexImage2D: level=%i fmt=%i width=%i height=%i type=%i data=%x",
+										   uploadLevel, glesFormat, width, height, datatype, (UInt32)feedData);
+				GLES_CHK(glTexImage2D (GL_TEXTURE_2D, uploadLevel, internalFormat, width, height, 0, glesFormat, datatype, feedData));
+			}
+		}
+		if( gGraphicsCaps.gles20.needFlushAfterTextureUpload )
+			GLES_CHK(glFlush());
+
+		// Go to next mip level
+		int levelSize = CalculateImageSize (width, height, format);;
+		uploadedSize += levelSize;
+		srcData += levelSize;
+		AssertIf( width == 1 && height == 1 && level != maxLevel );
+		width = std::max( width / 2, 1 );
+		height = std::max( height / 2, 1 );
+	}
+	REGISTER_EXTERNAL_GFX_ALLOCATION_REF(tid.m_ID, uploadedSize, tid.m_ID);
+
+	AssertIf( baseLevel > maxLevel );
+
+	if( decompressBuffer )
+		delete[] decompressBuffer;
+}
+
+void UploadTextureSubData2DGLES2( TextureID glname, UInt8* srcData,
+								 int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace )
+{
+	Assert( !IsAnyCompressedTextureFormat( format ) );
+
+	bool uploadIsCompressed, decompressOnTheFly;
+	TextureFormat uploadFormat = GetUploadFormat(format, uploadIsCompressed, decompressOnTheFly);
+	Assert( !uploadIsCompressed );
+	Assert( !decompressOnTheFly );
+
+	GLuint targetTex = (GLuint)TextureIdMap::QueryNativeTexture(glname);
+
+	Assert(targetTex != 0);
+	if(targetTex == 0)
+		return;
+
+	GetRealGfxDevice().SetTexture (kShaderFragment, 0, 0, glname, kTexDim2D, std::numeric_limits<float>::infinity());
+	GLES_CHK(glActiveTexture(GL_TEXTURE0));
+	GLES_CHK(glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
+
+	UInt8* decompressBuffer = NULL;
+	UInt8* feedData = srcData;
+
+	// Allocate temporary memory and swizzle texture
+	if( uploadFormat != format )
+	{
+		int decompressedSize = CalculateImageSize (width, height, uploadFormat);
+		if (decompressBuffer == NULL)
+			decompressBuffer = new UInt8[decompressedSize];
+		feedData = decompressBuffer;
+
+		ImageReference src (width, height, GetRowBytesFromWidthAndFormat (width, format), format, srcData);
+		ImageReference dst (width, height, GetRowBytesFromWidthAndFormat (width, uploadFormat), uploadFormat, feedData);
+		dst.BlitImage( src );
+	}
+#if UNITY_PEPPER
+	else if (uploadFormat == kTexFormatARGB4444)
+	{
+		feedData = SwizzleRGBA4444 (srcData, &decompressBuffer, width, height);
+	}
+#endif
+
+	// xenon, for real?
+	bool isSRGB = (colorSpace == kTexColorSpaceSRGBXenon || colorSpace == kTexColorSpaceSRGB);
+
+	int glesFormat, datatype;
+	GetUncompressedTextureFormat (uploadFormat, isSRGB, &glesFormat, &datatype);
+
+	GLES_CHK(glTexSubImage2D( GL_TEXTURE_2D, mipLevel, x, y, width, height, glesFormat, datatype, feedData ));
+
+	if( gGraphicsCaps.gles20.needFlushAfterTextureUpload )
+		GLES_CHK(glFlush());
+
+	if( decompressBuffer )
+		delete[] decompressBuffer;
+}
+
+void UploadTextureCubeGLES2(
+	TextureID tid, UInt8* srcData, int faceDataSize, int size,
+	TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace )
+{
+	bool uploadIsCompressed, decompressOnTheFly;
+	TextureFormat uploadFormat = GetUploadFormat(format, uploadIsCompressed, decompressOnTheFly);
+	DBG_TEXTURE_VERBOSE_GLES20("TextureCUBE #%i (%ix%ix6) unityFmt: %d, uploadFmt: %d, compressed: %d, decompressOnCpu: %d",
+							   tid.m_ID, size, size, format, uploadFormat, (int)uploadIsCompressed, (int)decompressOnTheFly);
+	REGISTER_EXTERNAL_GFX_DEALLOCATION(tid.m_ID);
+
+	TextureIdMapGLES20_QueryOrCreate(tid);
+	GetRealGfxDevice().SetTexture (kShaderFragment, 0, 0, tid, kTexDimCUBE, std::numeric_limits<float>::infinity());
+	glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+
+	// xenon, for real?
+	bool isSRGB = (colorSpace == kTexColorSpaceSRGBXenon || colorSpace == kTexColorSpaceSRGB);
+
+	UInt8* decompressBuffer = NULL;
+
+	const GLenum faces[6] =
+	{
+		GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+		GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+		GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+		GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+		GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+		GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+	};
+	int uploadedSize = 0;
+	int maxLevel = mipCount - 1;
+	for (int face=0;face<6;face++)
+	{
+		int mipSize = size;
+		UInt8* data = srcData + face * faceDataSize;
+		int glesFormat, datatype, size;
+
+		for( int level=0;level<=maxLevel;level++ )
+		{
+			UInt8* feedData;
+
+			// Allocate temporary memory and decompress texture
+			if( decompressOnTheFly )
+			{
+				int dstSize = std::max( mipSize, 4 );
+				int decompressedSize = CalculateImageSize( dstSize, dstSize, uploadFormat );
+				if( decompressBuffer == NULL )
+					decompressBuffer = new UInt8[decompressedSize];
+				feedData = decompressBuffer;
+				DecompressNativeTextureFormat( format, mipSize, mipSize, (UInt32*)data, dstSize, dstSize, (UInt32*)feedData );
+				//SetUnpackClientStorage (false);
+			}
+			// Allocate temporary memory and swizzle texture
+			else if( uploadFormat != format )
+			{
+				int decompressedSize = CalculateImageSize (mipSize, mipSize, uploadFormat);
+				if (decompressBuffer == NULL)
+					decompressBuffer = new UInt8[decompressedSize];
+				feedData = decompressBuffer;
+
+				ImageReference src (mipSize, mipSize, GetRowBytesFromWidthAndFormat (mipSize, format), format, data);
+				ImageReference dst (mipSize, mipSize, GetRowBytesFromWidthAndFormat (mipSize, uploadFormat), uploadFormat, feedData);
+				dst.BlitImage( src );
+			}
+#if UNITY_PEPPER
+			else if (uploadFormat == kTexFormatARGB4444)
+			{
+				feedData = SwizzleRGBA4444 (srcData, &decompressBuffer, mipSize, mipSize);
+			}
+#endif
+			// Just feed the data
+			else
+			{
+				feedData = data;
+			}
+
+			// Upload
+			if( uploadIsCompressed )
+			{
+				GetCompressedTextureFormat( uploadFormat, isSRGB, mipSize, mipSize, &glesFormat, &size );
+				GLES_CHK(glCompressedTexImage2D (faces[face], level, glesFormat, mipSize, mipSize, 0, size, feedData));
+			}
+			else
+			{
+				GetUncompressedTextureFormat( uploadFormat, isSRGB, &glesFormat, &datatype );
+
+				int internalFormat = glesFormat;
+			#if UNITY_IPHONE
+				//APPLE_texture_format_BGRA8888 dictates internal format for GL_BGRA_EXT to be GL_RGBA
+				if(glesFormat == GL_BGRA_EXT)
+					internalFormat = GL_RGBA;
+			#endif
+
+				GLES_CHK(glTexImage2D (faces[face], level, internalFormat, mipSize, mipSize, 0, glesFormat, datatype, feedData));
+			}
+
+			if( gGraphicsCaps.gles20.needFlushAfterTextureUpload )
+				GLES_CHK(glFlush());
+
+			//GLAssert ();
+			int levelSize = CalculateImageSize( mipSize, mipSize, format );
+			uploadedSize += levelSize;
+			data += levelSize;
+			AssertIf( mipSize == 1 && level != maxLevel );
+
+			mipSize = std::max( mipSize / 2, 1 );
+		}
+	}
+	REGISTER_EXTERNAL_GFX_ALLOCATION_REF(tid.m_ID, uploadedSize, tid.m_ID);
+
+	if( decompressBuffer )
+		delete[] decompressBuffer;
+}
+
+#if UNITY_IPHONE
+	extern		bool  				IsActiveMSAARenderTargetGLES2();
+	extern 		RenderSurfaceBase*	ResolveMSAASetupFBO(void*, int, GLuint, GLuint);
+	extern 		void  				ResolveMSAASetupFBO_Cleanup(RenderSurfaceBase*);
+
+	extern "C"	void* 				UnityDefaultFBOColorBuffer();
+#endif
+
+bool ReadbackTextureGLES2(ImageReference& image, int left, int bottom, int width, int height, int destX, int destY, GLuint globalSharedFBO, GLuint helperFBO)
+{
+	bool result = true;
+
+#if UNITY_IPHONE
+	RenderSurfaceBase* resolveRS = 0;
+	GLint oldFBO = 0;
+	if(IsActiveMSAARenderTargetGLES2() && gGraphicsCaps.gles20.hasAppleMSAA)
+	{
+		GLES_CHK(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldFBO));
+		resolveRS = ResolveMSAASetupFBO(UnityDefaultFBOColorBuffer(), 0, globalSharedFBO, helperFBO);
+	}
+#endif
+
+	int glesFormat, datatype;
+
+
+	// The whole image we're reading into can be larger than the rect we read, so setup the alignment.
+	GLES_CHK(glPixelStorei( GL_PACK_ALIGNMENT, 1 ));
+
+	void* dstImagePtr[kTexFormatPCCount] =
+	{
+		0,									//
+		image.GetRowPtr(destY) + destX,		//  kTexFormatAlpha8
+		0,									//	kTexFormatARGB4444
+		image.GetRowPtr(destY) + destX * 3,	//	kTexFormatRGB24
+		image.GetRowPtr(destY) + destX * 4,	//	kTexFormatRGBA32
+		image.GetRowPtr(destY) + destX * 4,	//	kTexFormatARGB32
+		0,									//	kTexFormatARGBFloat
+		image.GetRowPtr(destY) + destX * 2,	//	kTexFormatRGB565
+		0,									//	kTexFormatBGR24
+
+		0,									//	kTexFormatAlphaLum16
+		0,									//	kTexFormatDXT1
+		0,									//	kTexFormatDXT3
+		0,									//	kTexFormatDXT5
+		0									//	kTexFormatRGBA4444
+	};
+
+	GetUncompressedTextureFormat( image.GetFormat(), false, &glesFormat, &datatype );
+	void* dstPtr = dstImagePtr[image.GetFormat()];
+	switch( image.GetFormat() )
+	{
+		case kTexFormatRGB565:
+		case kTexFormatRGBA32:
+		case kTexFormatARGB32:
+		case kTexFormatRGB24:
+		case kTexFormatAlpha8:
+			{
+				int readFormat, readType;
+				GLES_CHK(glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &readFormat));
+				GLES_CHK(glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &readType));
+
+				// Check if reading format/type matches our image's format/type, and width (as glReadPixels knows nothing about dst pitch)
+				if (glesFormat == readFormat && datatype == readType && width == image.GetWidth())
+				{
+					GLES_CHK(glReadPixels(left, bottom, width, height, glesFormat, datatype, dstPtr));
+				}
+				else
+				{
+					// Read as GL_RGBA/GL_UNSIGNED_BYTE, because it's always valid in OpenGL ES, and convert it to specified image format
+					int readFormat     = kTexFormatRGBA32;
+					int readFormatSize = CalculateImageSize (width, height, readFormat);
+
+					GetUncompressedTextureFormat( readFormat, false, &glesFormat, &datatype );
+
+					UInt8* data = new UInt8[readFormatSize];
+					GLES_CHK(glReadPixels(left, bottom, width, height, glesFormat, datatype, data));
+
+					ImageReference src (width, height, GetRowBytesFromWidthAndFormat (width, readFormat), readFormat, data);
+					ImageReference dst (width, height, image.GetRowBytes(), image.GetFormat(), dstPtr);
+					dst.BlitImage( src );
+
+					delete[]data;
+				}
+			}
+			break;
+		default:
+			AssertString ("Not Supported");
+			result = false;
+	}
+
+#if UNITY_IPHONE
+	if(resolveRS)
+	{
+		GLES_CHK(glBindFramebuffer(GL_FRAMEBUFFER, oldFBO));
+		ResolveMSAASetupFBO_Cleanup(resolveRS);
+	}
+#endif
+
+	return result;
+}
+
+#endif // GFX_SUPPORTS_OPENGLES20