diff options
Diffstat (limited to 'Runtime/Graphics/Texture2D.cpp')
| -rw-r--r-- | Runtime/Graphics/Texture2D.cpp | 1422 |
1 files changed, 1422 insertions, 0 deletions
diff --git a/Runtime/Graphics/Texture2D.cpp b/Runtime/Graphics/Texture2D.cpp new file mode 100644 index 0000000..691dfd9 --- /dev/null +++ b/Runtime/Graphics/Texture2D.cpp @@ -0,0 +1,1422 @@ +#include "UnityPrefix.h" +#include "Configuration/UnityConfigure.h" +#include "Texture2D.h" +#include "Image.h" +#include "RenderTexture.h" +#include "Runtime/Utilities/BitUtility.h" +#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h" +#include "S3Decompression.h" +#include "Runtime/Camera/RenderManager.h" +#include "Runtime/Serialize/SwapEndianArray.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Math/Color.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/GfxDevice/GfxDeviceConfigure.h" +#include "ImageConversion.h" +#include "Runtime/Misc/Allocator.h" +#include "DXTCompression.h" +#include "Runtime/Serialize/PersistentManager.h" +#include "Runtime/BaseClasses/IsPlaying.h" +#include "Runtime/Profiler/Profiler.h" +#include "Runtime/Profiler/MemoryProfiler.h" +#include "Runtime/Threads/Thread.h" +#include "Runtime/Threads/Mutex.h" +#include "Runtime/Math/ColorSpaceConversion.h" +#include "Runtime/Misc/BuildSettings.h" + +#if UNITY_EDITOR +#include "CubemapTexture.h" +#endif + +#if UNITY_WII +#include "PlatformDependent/wii/WiiUtility.h" +#endif + +#if ENABLE_TEXTUREID_MAP +#include "Runtime/GfxDevice/TextureIdMap.h" +#endif + + +#define USE_IMMEDIATE_INTEGRATION (UNITY_IPHONE || UNITY_ANDROID || UNITY_BB10 || UNITY_PS3 || UNITY_XENON || UNITY_TIZEN) + + +PROFILER_INFORMATION(gIntegrateLoadedImmediately, "Texture.IntegrateLoadedImmediately", kProfilerLoading) +PROFILER_INFORMATION(gAwakeFromLoadTex2D, "Texture.AwakeFromLoad", kProfilerLoading) + +/* + Regular and non-power-of-two textures: + + For regular textures, all TextureRepresentation's are exactly the same; and the data is allocated just + once (all representations point to the same data). + + For NPOT textures: + * m_TexData is what is serialized (non power of two). Mip maps use floor(size/2) convention, + DXT compression is actually next multiple of 4. + * If no mipmaps are specified and NPOTRestricted is supported - act as regular texture + * If mipmaps are specified and NPOTFULL is supported - act as regular texture + * If NPOT textures are not supported: + * m_Tex is scaled up to POT at load time. DXT source gets decompressed into ARGB32. + * m_TexPadded is POT size, but the original is padded by repeating border pixels. GUITexture uses it. +*/ + +bool Texture2D::s_ScreenReadAllowed = true; + +static inline UInt32 GetBytesForOnePixel( TextureFormat format ) +{ + return IsAnyCompressedTextureFormat(format) ? 0 : GetBytesFromTextureFormat(format); +} + +bool IsNPOTTextureAllowed(bool hasMipMap) +{ + if(IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_1_a1)) + return hasMipMap ? gGraphicsCaps.npot == kNPOTFull : gGraphicsCaps.npot >= kNPOTRestricted; + else + return false; +} + +static int GetNextAllowedTextureSize(int size, bool hasMipMap, TextureFormat format) +{ + int multipleMask = GetTextureSizeAllowedMultiple(format) - 1; + size = (size + multipleMask) & ~multipleMask; + if (!IsNPOTTextureAllowed(hasMipMap)) + size = NextPowerOfTwo(size); + return size; +} + + +Texture2D::TextureRepresentation::TextureRepresentation() +: data(NULL) +, width(0) +, height(0) +, format(kTexFormatARGB32) +, imageSize(0) +{ +} + +Texture2D::Texture2D (MemLabelId label, ObjectCreationMode mode) +: Super(label, mode) +, m_InitFlags(0) +{ + #if UNITY_EDITOR + m_IgnoreMasterTextureLimit = false; + #endif + + m_MipMap = false; + m_TextureDimension = kTexDimNone; + +#if UNITY_EDITOR + m_EditorDontWriteTextureData = false; + m_AlphaIsTransparency = false; +#endif + + m_PowerOfTwo = true; + + m_ImageCount = 0; + + m_IsReadable = true; + m_IsUnreloadable = false; + m_ReadAllowed = true; + m_TextureUploaded = false; + m_UnscaledTextureUploaded = false; + + // We use unchecked version since we may not be on the main thread + // This means CreateTextureID() implementation must be thread safe! + m_UnscaledTexID = GetUncheckedGfxDevice().CreateTextureID(); +} + +void Texture2D::Reset () +{ + Super::Reset(); + + m_TextureSettings.Reset (); +} + +//#define LOG_AWAKE(x, arg) printf_console(x, arg); +#define LOG_AWAKE(x, arg) + +typedef std::vector<Texture2D*> TexturesT; +static TexturesT g_TexturesToUploadOnMainThread; +static Mutex g_UploadMutex; + +void Texture2D::AwakeFromLoadThreaded() +{ + Super::AwakeFromLoadThreaded(); + +#if USE_IMMEDIATE_INTEGRATION + LOG_AWAKE("Texture2D: AwakeFromLoadThreaded (%s)\n", GetName()); + g_UploadMutex.Lock(); + g_TexturesToUploadOnMainThread.push_back(this); + g_UploadMutex.Unlock(); + // Pause loading for a while + // this will allow main thread to start integrating previously loaded textures + Thread::Sleep(0.001); +#endif // USE_IMMEDIATE_INTEGRATION +} + +// Helps to avoid memory peak while loading the level on platforms where graphics driver creates an internal copy of texture data +// +// Memory peak arrises in the following scenario: +// 1) [Load thread] all texture assets are loaded +// 2) [Main thread] for every asset (OnAwake) +// a) texture data is uploaded to graphics driver (copy) +// b) texture data is released (in case of NonReadable textures) +// +// Instead we do: +// 1) [Load thread] load 1 texture asset +// 2) [Load thread] stall for a moment and allow Main thread to start uploading +// 3) [Main thread] upload as much texture data as possible +// 4) [Main thread] if significantly behind Load thread, then block Load thread +// 5) continue for all assets +// +// NOTE: Main thread calls IntegrateLoadedImmediately() from PreloadManager::UpdatePreloadingSingleStep() +void Texture2D::IntegrateLoadedImmediately() +{ +#if USE_IMMEDIATE_INTEGRATION + + PROFILER_AUTO(gIntegrateLoadedImmediately, NULL) + + g_UploadMutex.Lock(); + TexturesT toUpload = g_TexturesToUploadOnMainThread; + g_TexturesToUploadOnMainThread.clear(); + + size_t totalTextureSize = 0; + for (size_t q = 0; q < toUpload.size(); ++q) + totalTextureSize += toUpload[q]->m_TexData.imageSize; + + // Evalute texture data ready for immediate integration + // If we have too much data to upload, then block the loading thread! + // Loading thread will stall until all pending data is uploaded. + bool blockLoadingThread = totalTextureSize > (512*1024); + + // Avoid stalling on every texture (if possible) to improve loading speed + if (!blockLoadingThread) + { + g_UploadMutex.Unlock(); + } + else + { + LOG_AWAKE("Texture2D: IntegrateLoadedImmediately() will block loader thread, pending texture data size: %d bytes\n", totalTextureSize); + } + + for (size_t q = 0; q < toUpload.size(); ++q) + { + Texture2D* tex = toUpload[q]; + LOG_AWAKE("Texture2D: Immediately upload texture data (%s)\n", tex->GetName()); + if (tex->m_TexData.data != NULL) + tex->UploadTexture (false); + } + + if (blockLoadingThread) + g_UploadMutex.Unlock(); + +#endif // USE_IMMEDIATE_INTEGRATION +} + +void Texture2D::AwakeFromLoad (AwakeFromLoadMode awakeMode) +{ + SET_ALLOC_OWNER(this); + Super::AwakeFromLoad (awakeMode); + + if( (awakeMode == kDefaultAwakeFromLoad || awakeMode == kInstantiateOrCreateFromCodeAwakeFromLoad) + && m_TexData.data == NULL + ) + { + // actually pretty valid + return; + } + +#if USE_IMMEDIATE_INTEGRATION + // Check if texture data was already uploaded by IntegrateLoadedImmediately() + if ((awakeMode & kDidLoadThreaded) != 0) + { + bool dynamicTexture = m_TexData.imageSize == 0; + Assert(m_TextureUploaded || dynamicTexture); + + if (m_TextureUploaded) + return; + } + LOG_AWAKE("Texture2D: Upload texture data in Awake (%s)\n", GetName()); +#endif // USE_IMMEDIATE_INTEGRATION + + PROFILER_AUTO(gAwakeFromLoadTex2D, this) + UploadTexture (false); +} + +Texture2D::~Texture2D () +{ + DestroyTexture (); + MainThreadCleanup (); +} + +bool Texture2D::MainThreadCleanup () +{ + DeleteGfxTexture (); + + Texture::s_TextureIDMap.erase (m_UnscaledTexID); + + // FreeTextureID() implementation must be thread safe! + GetUncheckedGfxDevice().FreeTextureID(m_UnscaledTexID); + m_UnscaledTexID = TextureID(); + + return Super::MainThreadCleanup (); +} + + +static int SourceMipLevelForBlit( int srcWidth, int srcHeight, int dstWidth, int dstHeight ) +{ + int level = HighestBit( NextPowerOfTwo(srcWidth) ) - HighestBit( NextPowerOfTwo(dstWidth) ); + level = std::max( level, HighestBit( NextPowerOfTwo(srcHeight) ) - HighestBit( NextPowerOfTwo(dstHeight) ) ); + level = std::max( 0, level ); + return level; +} + +// Compressed->compressed extraction. Copies compressed blocks and pads the remainder with +// transparent black. +void Texture2D::ExtractCompressedImageInternal( UInt8* dst, int dstWidth, int dstHeight, int imageIndex ) const +{ + AssertIf( imageIndex < 0 || imageIndex >= m_ImageCount ); + + TextureRepresentation const& rep =m_TexData; + AssertIf( !IsAnyCompressedTextureFormat( rep.format ) ); + if (m_TexData.data == NULL) + { + ErrorString ("Texture data can not be accessed"); + return; + } + + int mipmapLevel = SourceMipLevelForBlit( rep.width, rep.height, dstWidth, dstHeight ); + mipmapLevel = std::min( mipmapLevel, CountDataMipmaps() - 1 ); + int mipmapoffset = CalculateMipMapOffset( rep.width, rep.height, rep.format, mipmapLevel ); + int width = std::max( rep.width >> mipmapLevel, 1 ); + int height = std::max( rep.height >> mipmapLevel, 1 ); + + // pad-copy compressed->compressed + BlitCopyCompressedImage( rep.format, rep.data + imageIndex * rep.imageSize + mipmapoffset, + width, height, dst, dstWidth, dstHeight, true ); +} + + +bool Texture2D::ExtractImageInternal( ImageReference* image, bool scaleToSize, int imageIndex ) const +{ + AssertIf (imageIndex < 0 || imageIndex >= m_ImageCount); + + TextureRepresentation const& rep = m_TexData; + if(rep.data == NULL) + { + ErrorString ("Texture is not accessible."); + return false; + } + + int mipmapLevel = SourceMipLevelForBlit( rep.width, rep.height, image->GetWidth(), image->GetHeight() ); + mipmapLevel = std::min( mipmapLevel, CountDataMipmaps() - 1 ); + int mipmapoffset = CalculateMipMapOffset( rep.width, rep.height, rep.format, mipmapLevel ); + int width = std::max( rep.width >> mipmapLevel, 1 ); + int height = std::max( rep.height >> mipmapLevel, 1 ); + + if( IsAnyCompressedTextureFormat(rep.format) ) + { + // Decompress into upper multiple-of-4 size + int decompWidth = (width + 3) / 4 * 4; + int decompHeight = (height + 3) / 4 * 4; + + Image decompressed( decompWidth, decompHeight, kTexFormatRGBA32 ); + UInt8* compressed = rep.data + imageIndex * rep.imageSize + mipmapoffset; + + if (!DecompressNativeTextureFormatWithMipLevel( rep.format, width, height, mipmapLevel, (UInt32*)compressed, decompWidth, decompHeight, (UInt32*)decompressed.GetImageData() )) + return false; + + // Clip this back to original size + ImageReference clipped = decompressed.ClipImage( 0, 0, width, height ); + + if( scaleToSize ) + { + image->BlitImage( clipped, ImageReference::BLIT_BILINEAR_SCALE ); + } + else + { + AssertIf( width > image->GetWidth() || height > image->GetHeight() ); + image->BlitImage( clipped, ImageReference::BLIT_COPY ); + PadImageBorder( *image, width, height ); + } + return true; + } + else + { + ImageReference source( width, height, width * GetBytesFromTextureFormat(rep.format), + rep.format, rep.data + imageIndex * rep.imageSize + mipmapoffset); + + if( scaleToSize ) + { + image->BlitImage( source, ImageReference::BLIT_BILINEAR_SCALE ); + } + else + { + AssertIf( width > image->GetWidth() || height > image->GetHeight() ); + image->BlitImage( source, ImageReference::BLIT_COPY ); + PadImageBorder( *image, width, height ); + } + return true; + } + + return false; +} +bool Texture2D::ExtractImage (ImageReference* image, int imageIndex) const +{ + return ExtractImageInternal( image, true, imageIndex ); +} + +bool Texture2D::HasMipMap() const { + return m_MipMap; +} + +int Texture2D::CountMipmaps() const +{ + if (m_MipMap) + return CalculateMipMapCount3D( m_glWidth, m_glHeight, 1 ); + else + return 1; +} +int Texture2D::CountDataMipmaps() const +{ + if (m_MipMap) + return CalculateMipMapCount3D( m_TexData.width, m_TexData.height, 1 ); + else + return 1; +} + +UInt8* Texture2D::AllocateTextureData (int imageSize, TextureFormat format, bool initMemory) +{ + // Allocate one more pixel because software bi-linear filtering might require it. + int allocSize = imageSize + GetBytesForOnePixel(format); + void* buffer = UNITY_MALLOC_ALIGNED (GetTextureDataMemoryLabel(), allocSize, 32); + + // In the past the memory manager cleared textures created from script to 0xcd. + // Let's keep doing that even though a color like white makes more sense (case 564961). + if (initMemory && buffer) + memset(buffer, 0xcd, allocSize); + + return static_cast<UInt8*>(buffer); +} + +void Texture2D::DeallocateTextureData (UInt8* tex) +{ + UNITY_FREE (GetTextureDataMemoryLabel(), tex); +} + +void Texture2D::InitTextureInternal (int width, int height, TextureFormat format, int imageSize, UInt8* buffer, int options, int imageCount) +{ + // Cleanup old memory + if ((options & kThreadedInitialize) == 0) + { + DestroyTexture (); + SetDirty (); + } + else + { + AssertIf(m_TexData.data != NULL); + } + + m_TextureDimension = kTexDim2D; + + m_TexData.width = width; + m_TexData.height = height; + m_TexData.format = format; + m_TexData.imageSize = imageSize; + m_TexData.data = buffer; + m_MipMap = options & kMipmapMask; + m_InitFlags = options; + m_ImageCount = imageCount; + UpdatePOTStatus(); + + m_glWidth = GetNextAllowedTextureSize(m_TexData.width, m_MipMap, format); + m_glHeight = GetNextAllowedTextureSize(m_TexData.height, m_MipMap, format); + SetTexelSize( 1.0f/m_glWidth, 1.0f/m_glHeight ); +} + +bool Texture2D::InitTexture (int width, int height, TextureFormat format, int options, int imageCount, intptr_t nativeTex) +{ + SET_ALLOC_OWNER(this); + if (width < 0 || width > 10000 || height < 0 || height > 10000) + { + ErrorStringObject ("Texture has out of range width / height", this); + return false; + } + + if (!IsValidTextureFormat(format)) + { + ErrorStringObject ("TextureFormat is invalid!", this); + return false; + } + + int imageSize; + if( options & kMipmapMask) + imageSize = CalculateImageMipMapSize( width, height, format ); + else + imageSize = CalculateImageSize( width, height, format ); + + unsigned int tlen = imageSize * imageCount; + // probably an multiplication overflow + if (imageSize != 0 && imageCount != tlen / imageSize) + return false; + // probably an addition overflow + if (tlen + GetBytesForOnePixel(format) < tlen) + return false; + + bool allocData = ENABLE_TEXTUREID_MAP == 0 || nativeTex == 0; + +#if ENABLE_TEXTUREID_MAP + if(nativeTex) + TextureIdMap::UpdateTexture(m_TexID, GetGfxDevice().CreateExternalTextureFromNative(nativeTex)); +#endif + + UInt8* buffer = allocData ? AllocateTextureData(imageSize * imageCount, format, true) : 0; + InitTextureInternal (width, height, format, imageSize, buffer, options, imageCount); + + return true; +} + +void Texture2D::RebuildMipMap () +{ + TextureRepresentation& rep = m_TexData; + + if( rep.data == NULL || !m_MipMap ) + return; + if( IsAnyCompressedTextureFormat(rep.format) ) + { + ErrorString ("Rebuilding mipmaps of compressed textures is not supported"); + return; + } + + for( int i=0;i<m_ImageCount;i++ ) + CreateMipMap (rep.data + rep.imageSize * i, rep.width, rep.height, 1, rep.format); +} + + +#if UNITY_EDITOR +void Texture2D::SetImage (const ImageReference& image, int flags) +{ + SET_ALLOC_OWNER(this); + InitTexture( image.GetWidth (), image.GetHeight (), image.GetFormat (), flags ); + + int bytesPerPixel = GetBytesFromTextureFormat (m_TexData.format); + + ImageReference dst( m_TexData.width, m_TexData.height, bytesPerPixel * m_TexData.width, m_TexData.format, m_TexData.data ); + if (image.GetImageData () != NULL) + dst.BlitImage (image); + + RebuildMipMap (); + + UploadTexture (true); + SetDirty (); +} +#endif + + + +bool Texture2D::GetImageReferenceInternal (ImageReference* image, int frame, int miplevel) const +{ + TextureRepresentation const& rep = m_TexData; + + if( rep.data == NULL || IsAnyCompressedTextureFormat(rep.format) ) + return false; + + AssertIf (frame >= m_ImageCount); + AssertIf (miplevel >= CountDataMipmaps ()); + + UInt8* base = rep.data + frame * rep.imageSize; + base += CalculateMipMapOffset( rep.width, rep.height, rep.format, miplevel ); + int width = std::max (rep.width >> miplevel, 1); + int height = std::max (rep.height >> miplevel, 1); + + *image = ImageReference( width, height, GetRowBytesFromWidthAndFormat(width, rep.format), rep.format, base ); + return true; +} + +bool Texture2D::GetWriteImageReference (ImageReference* image, int frame, int miplevel) +{ + return GetImageReferenceInternal (image, frame, miplevel); +} + + +void Texture2D::ApplySettings() +{ + TextureDimension texdim = GetDimension(); + m_TextureSettings.Apply( GetTextureID(), texdim, HasMipMap(), GetActiveTextureColorSpace()); + if( m_UnscaledTextureUploaded ) + m_TextureSettings.Apply( GetUnscaledTextureID(), texdim, HasMipMap(), GetActiveTextureColorSpace() ); + + NotifyMipBiasChanged(); +} + +void Texture2D::UpdatePOTStatus() +{ + m_PowerOfTwo = IsPowerOfTwo(m_TexData.width) && IsPowerOfTwo(m_TexData.height); + + // force clamp if we will keep it npot + if(!m_PowerOfTwo && !m_MipMap && gGraphicsCaps.npot == kNPOTRestricted) + m_TextureSettings.m_WrapMode = kTexWrapClamp; +} + + +void Texture2D::UploadTexture (bool dontUseSubImage) +{ + if (m_TexData.data == NULL) + { + ErrorString("No Texture memory available to upload"); + return; + } + if (m_TexData.width == 0 || m_TexData.height == 0) + { + return; + } + + TextureRepresentation scaled = m_TexData; + TextureRepresentation padded = m_TexData; + + InitTextureRepresentations(&scaled, &padded); + + int mipCount = CountMipmaps(); + + int masterTextureLimit = Texture::GetMasterTextureLimit(); + #if UNITY_EDITOR + if (m_IgnoreMasterTextureLimit) + masterTextureLimit = 0; + #endif + + // Master texture limit must be clamped to mipCount-1 or otherwise GfxDevice won't upload anything + masterTextureLimit = min(mipCount-1, masterTextureLimit); + + TextureUsageMode usageMode = GetUsageMode(); + + // upload regular texture + { + TextureRepresentation& rep = scaled; + UInt8* srcData = rep.data; + UInt32 uploadFlags = (dontUseSubImage || !m_TextureUploaded) ? GfxDevice::kUploadTextureDontUseSubImage : GfxDevice::kUploadTextureDefault; + if (m_InitFlags & kOSDrawingCompatible) + uploadFlags |= GfxDevice::kUploadTextureOSDrawingCompatible; + GetGfxDevice().UploadTexture2D( GetTextureID(), GetDimension(), srcData, rep.imageSize, rep.width, rep.height, rep.format, mipCount, uploadFlags, masterTextureLimit, usageMode, GetActiveTextureColorSpace() ); + Texture::s_TextureIDMap.insert (std::make_pair(GetTextureID(),this)); + m_TextureSettings.Apply( GetTextureID(), GetDimension(), m_MipMap, GetActiveTextureColorSpace()); + m_TextureUploaded = true; + } + + // upload unscaled one if NPOT and not supported + if( m_TexData.width != m_glWidth || m_TexData.height != m_glHeight ) + { + TextureRepresentation& rep = padded; + UInt8* srcData = rep.data; + + UInt32 uploadFlags = (dontUseSubImage || !m_UnscaledTextureUploaded) ? GfxDevice::kUploadTextureDontUseSubImage : GfxDevice::kUploadTextureDefault; + if (m_InitFlags & kOSDrawingCompatible) + uploadFlags |= GfxDevice::kUploadTextureOSDrawingCompatible; + + m_UnscaledTextureUploaded = true; // must be before Upload in order for GetUnscaledGLTextureName() to return the right value + TextureID tid = GetUnscaledTextureID(); + GetGfxDevice().UploadTexture2D( tid, GetDimension(), srcData, rep.imageSize, rep.width, rep.height, rep.format, mipCount, uploadFlags, masterTextureLimit, usageMode, GetActiveTextureColorSpace() ); + Texture::s_TextureIDMap.insert (std::make_pair(tid,this)); + m_TextureSettings.Apply( tid, GetDimension(), m_MipMap, GetActiveTextureColorSpace() ); + } + +#if UNITY_XENON && !MASTER_BUILD + GetGfxDevice().SetTextureName( GetTextureID(), GetName() ); +#endif + +#if UNITY_EDITOR + DestroyTextureRepresentations(&scaled, &padded, false); +#elif UNITY_WII + // On Wii texture data is being directly referenced from m_TexData.data, so don't delete it after uploading + DestroyTextureRepresentations(&scaled, &padded, false); +#else + DestroyTextureRepresentations(&scaled, &padded, !m_IsReadable); + if(!m_IsReadable) + m_TexData.imageSize = 0; +#endif +} + +void Texture2D::DestroyTextureRepresentation( TextureRepresentation* rep ) +{ + if( rep ) + { + if( rep->data == m_TexData.data ) + rep->data = NULL; + + DeallocateTextureData (rep->data); + rep->data = NULL; + } +} + +void Texture2D::DestroyTextureRepresentations( TextureRepresentation* scaled, TextureRepresentation* padded, bool freeSourceImage ) +{ + DestroyTextureRepresentation(padded); + DestroyTextureRepresentation(scaled); + + if( freeSourceImage ) + { + DeallocateTextureData (m_TexData.data); + m_TexData.data = NULL; + } +} + +void Texture2D::DeleteGfxTexture () +{ + if (m_TextureUploaded) + { + ASSERT_RUNNING_ON_MAIN_THREAD + GetGfxDevice().DeleteTexture( GetTextureID() ); + m_TextureUploaded = false; + } + if (m_UnscaledTextureUploaded) + { + ASSERT_RUNNING_ON_MAIN_THREAD + GetGfxDevice().DeleteTexture( GetUnscaledTextureID() ); + m_UnscaledTextureUploaded = false; + } +} + + +void Texture2D::DestroyTexture () +{ + DestroyTextureRepresentations (0,0,true); + + DeleteGfxTexture (); +} + + +void Texture2D::UnloadFromGfxDevice(bool forceUnloadAll) +{ + if (m_IsUnreloadable && !forceUnloadAll) + return; + DeleteGfxTexture (); +} + +void Texture2D::UploadToGfxDevice() +{ + if (m_IsUnreloadable) + return; + + GfxDevice& device = GetGfxDevice(); + + // We need to load the texture data from disk. Awake FromLoad will be called during ReloadFromDisk. + bool needReloadFromDisk = (m_TexData.data == NULL && !m_IsReadable); + if (needReloadFromDisk) + { + TextureSettings settings = m_TextureSettings; + + GetPersistentManager().ReloadFromDisk(this); + + m_TextureSettings = settings; + ApplySettings(); + } + // Just upload the texture data we already have in memory + else + { + UploadTexture (true); + } +} + + +#if UNITY_EDITOR +struct TemporaryTextureSerializationRevert +{ + Texture2D* texture; + Texture2D::TextureRepresentation texData; + int imageCount; + bool isReadable; + + TemporaryTextureSerializationRevert (Texture2D& tex2D, bool doRevert) + { + texture = NULL; + + if (doRevert) + { + texture = &tex2D; + + texData = texture->m_TexData; + imageCount = texture->m_ImageCount; + isReadable = texture->m_IsReadable; + } + } + ~TemporaryTextureSerializationRevert () + { + if (texture != NULL) + { + texture->m_TexData = texData; + texture->m_ImageCount = imageCount; + texture->m_IsReadable = isReadable; + } + } +}; +#endif + +template<class TransferFunction> +void Texture2D::Transfer (TransferFunction& transfer) +{ + Super::Transfer (transfer); + +#if UNITY_EDITOR + + // Store serialization state temporarliy and revert it when exiting function + TemporaryTextureSerializationRevert revert(*this, !transfer.IsReading ()); + + // When writing dynamic font textures we don't want to write any texture data to disk + if (m_EditorDontWriteTextureData && !transfer.IsReading ()) + { + m_ImageCount = m_TexData.imageSize = m_TexData.height = m_TexData.width = 0; + m_TexData.data = NULL; + } + + // readable flag gets adjusted by forced readable flag + if (transfer.IsBuildingTargetPlatform(kBuildAnyPlayerData)) + m_IsReadable |= transfer.GetBuildUsage().forceTextureReadable; + + TRANSFER_EDITOR_ONLY_HIDDEN(m_AlphaIsTransparency); + transfer.Align(); +#endif + + // In case we're converting the texture data to another format, we also properly write out the format ID. + transfer.Transfer( m_TexData.width, "m_Width", kNotEditableMask ); + transfer.Transfer( m_TexData.height, "m_Height", kNotEditableMask ); + transfer.Transfer( m_TexData.imageSize, "m_CompleteImageSize", kNotEditableMask ); + transfer.Transfer( m_TexData.format, "m_TextureFormat", kHideInEditorMask ); + transfer.Transfer( m_MipMap, "m_MipMap", kNotEditableMask ); + + transfer.Transfer( m_IsReadable, "m_IsReadable"); + transfer.Transfer( m_ReadAllowed, "m_ReadAllowed", kNotEditableMask ); + transfer.Align(); + transfer.Transfer( m_ImageCount, "m_ImageCount", kNotEditableMask ); + transfer.Transfer( m_TextureDimension, "m_TextureDimension", kHideInEditorMask ); + transfer.Transfer( m_TextureSettings, "m_TextureSettings"); + transfer.Transfer( m_UsageMode, "m_LightmapFormat"); + transfer.Transfer( m_ColorSpace, "m_ColorSpace"); + + unsigned imageSizeXImageCount = m_ImageCount * m_TexData.imageSize; + + if (!transfer.IsWritingGameReleaseData ()) + transfer.TransferTypeless (&imageSizeXImageCount, "image data", kHideInEditorMask); + + if (transfer.IsReading ()) + { + DestroyTexture (); + Assert(GetMemoryLabel().label != kMemTextureCacheId); + m_TexData.data = AllocateTextureData(imageSizeXImageCount, m_TexData.format); + m_glWidth = GetNextAllowedTextureSize(m_TexData.width, m_MipMap, TextureFormat(m_TexData.format)); + m_glHeight = GetNextAllowedTextureSize(m_TexData.height, m_MipMap, TextureFormat(m_TexData.format)); + SetTexelSize( 1.0f/m_glWidth, 1.0f/m_glHeight ); + } + + // write tex image + if (transfer.IsWriting()) + { + const bool gpuBE = UNITY_EDITOR ? transfer.IsBuildingTargetPlatform(kBuildXBOX360) : false; + + UInt8* convertedData = NULL; + if( transfer.ConvertEndianess() ) + { + convertedData = AllocateTextureData(imageSizeXImageCount, m_TexData.format); + ConvertTextureEndianessWrite(m_TexData.format, m_TexData.data, convertedData, imageSizeXImageCount, gpuBE); + } + + if (transfer.IsWritingGameReleaseData ()) + transfer.TransferTypeless (&imageSizeXImageCount, "image data", kHideInEditorMask); + transfer.TransferTypelessData (imageSizeXImageCount, convertedData ? convertedData : m_TexData.data ); + + DeallocateTextureData(convertedData); + } + else + { + if( transfer.ConvertEndianess() ) + { + transfer.TransferTypelessData (imageSizeXImageCount, m_TexData.data); + ConvertTextureEndianessRead (m_TexData.format, m_TexData.data, imageSizeXImageCount); + } + else + { + transfer.TransferTypelessData (imageSizeXImageCount, m_TexData.data); + } + } + + AssertIf ( m_TexData.imageSize != 0 && m_TexData.data == NULL ); + + if( transfer.IsReading() ) + UpdatePOTStatus(); +} + +void ConvertTextureEndianessWrite (int format, UInt8* src, UInt8* dst, int size, bool bBigEndianGPU) +{ + memcpy (dst, src, size); + if (format == kTexFormatARGBFloat) + SwapEndianArray (dst, 4, size / 4); + else if (format == kTexFormatRGB565 || format == kTexFormatARGB4444 || format == kTexFormatRGBA4444) + SwapEndianArray (dst, 2, size / 2); + else if (bBigEndianGPU && (format == kTexFormatDXT1 || format == kTexFormatDXT3 || format == kTexFormatDXT5)) + SwapEndianArray (dst, 2, size / 2); + +} + +void ConvertTextureEndianessRead (int format, UInt8* dst, int size) +{ + if (format == kTexFormatARGBFloat) + SwapEndianArray (dst, 4, size / 4); + else if (format == kTexFormatRGB565 || format == kTexFormatARGB4444 || format == kTexFormatRGBA4444) + SwapEndianArray (dst, 2, size / 2); +} + + +void Texture2D::UpdateImageData () +{ + RebuildMipMap (); + UploadTexture (false); + SetDirty (); +} + +void Texture2D::UpdateImageDataDontTouchMipmap () +{ + UploadTexture (false); + SetDirty (); +} + + +TextureID Texture2D::GetUnscaledTextureID() const +{ + return m_UnscaledTextureUploaded ? m_UnscaledTexID : m_TexID; +} +int Texture2D::GetDataWidth() const +{ + return m_TexData.width; +} +int Texture2D::GetDataHeight() const +{ + return m_TexData.height; +} + + +void Texture2D::InitTextureRepresentation( TextureRepresentation* rep, int format, const char* tag ) +{ + Assert(rep); + + rep->width = GetNextAllowedTextureSize(m_TexData.width, m_MipMap, TextureFormat(format)); + rep->height = GetNextAllowedTextureSize(m_TexData.height, m_MipMap, TextureFormat(format)); + rep->format = format; + + if( m_MipMap ) + rep->imageSize = CalculateImageMipMapSize( rep->width, rep->height, rep->format ); + else + rep->imageSize = CalculateImageSize( rep->width, rep->height, rep->format ); + + rep->data = AllocateTextureData(rep->imageSize * m_ImageCount, rep->format); +} + +void Texture2D::ExtractMipLevel( TextureRepresentation* dst, int frame, int mipLevel, bool checkCompression, bool scaleToSize ) +{ + if (dst->width == 0 || dst->height == 0) + return; + + UInt8* data = dst->data + frame * dst->imageSize + CalculateMipMapOffset(dst->width, dst->height, dst->format, mipLevel ); + + + int width = std::max( dst->width >> mipLevel, 1 ); + int height = std::max( dst->height >> mipLevel, 1 ); + + if( checkCompression && IsAnyCompressedTextureFormat(dst->format) ) + { + ExtractCompressedImageInternal( data, width, height, frame ); + } + else + { + ImageReference ref( width, height, width*GetBytesFromTextureFormat(dst->format), dst->format, data ); + ExtractImageInternal( &ref, scaleToSize, frame ); + } +} + + +void Texture2D::InitTextureRepresentations(Texture2D::TextureRepresentation* scaled, Texture2D::TextureRepresentation* padded) +{ + Assert(scaled); + Assert(padded); + + if( m_TextureDimension == kTexDimDeprecated1D ) + m_TextureDimension = kTexDim2D; + + int multipleMask = GetTextureSizeAllowedMultiple(TextureFormat(m_TexData.format)) - 1; + bool isAllowedMultiple = (m_TexData.width & multipleMask) == 0 && (m_TexData.height & multipleMask) == 0; + if (isAllowedMultiple && (m_PowerOfTwo || IsNPOTTextureAllowed(m_MipMap))) + { + *scaled = *padded = m_TexData; + SetTexelSize( 1.0f / m_TexData.width, 1.0f / m_TexData.height ); + return; + } + + DebugAssertIf( m_PowerOfTwo ); + DebugAssertIf( !m_TexData.data ); + + InitTextureRepresentation(scaled, IsAnyCompressedTextureFormat(m_TexData.format) ? kTexFormatRGBA32 : m_TexData.format, "tex.scaled"); + InitTextureRepresentation(padded, m_TexData.format, "tex.padded"); + + int mipcount = CountMipmaps(); + for( int frame = 0; frame < m_ImageCount; ++frame ) + { + for( int mip = 0; mip < mipcount; ++mip ) + { + ExtractMipLevel(scaled, frame, mip, false, true); + ExtractMipLevel(padded, frame, mip, true, false); + } + } +} + +int Texture2D::GetRuntimeMemorySize() const +{ +#if ENABLE_MEM_PROFILER + return Super::GetRuntimeMemorySize() + + GetMemoryProfiler()->GetRelatedIDMemorySize(m_TexID.m_ID) + + (m_UnscaledTextureUploaded?GetMemoryProfiler()->GetRelatedIDMemorySize(GetUnscaledTextureID().m_ID):0); +#endif + return sizeof(Texture2D); +} + + +IMPLEMENT_CLASS (Texture2D) +IMPLEMENT_OBJECT_SERIALIZE (Texture2D) +INSTANTIATE_TEMPLATE_TRANSFER (Texture2D) + +bool Texture2D::CheckHasPixelData () const +{ + if (m_TexData.data != NULL) + return true; + + if (!m_IsReadable) + { + ErrorString(Format("Texture '%s' is not readable, the texture memory can not be accessed from scripts. You can make the texture readable in the Texture Import Settings.", GetName())); + } + else + { + ErrorString(Format("Texture '%s' has no data", GetName())); + } + return false; +} + + +void Texture2D::SetPixel (int frame, int x, int y, const ColorRGBAf& c) +{ + if (!CheckHasPixelData()) + return; + + if (frame > m_ImageCount) { + ErrorString (Format ("SetPixel called on an undefined image (valid values are 0 - %d", m_ImageCount - 1)); + return; + } + + ImageReference image; + if (GetWriteImageReference(&image, frame, 0)) + { + SetImagePixel (image, x, y, static_cast<TextureWrapMode>(GetSettings().m_WrapMode), c); + } + else + { + if( IsAnyCompressedTextureFormat(m_TexData.format) ) + { + ErrorString(kUnsupportedSetPixelOpFormatMessage); + } + else + { + ErrorString("Unable to retrieve image reference"); + } + } +} + +void Texture2D::SetPixels( int x, int y, int width, int height, int pixelCount, const ColorRGBAf* pixels, int miplevel, int frame ) +{ + if (width == 0 || height == 0) + return; // nothing to do + + if (!CheckHasPixelData()) + return; + + int mipcount = CountMipmaps(); + if (miplevel < 0 || miplevel >= mipcount) + { + ErrorString ("Invalid mip level"); + return; + } + + UInt8* data = m_TexData.data + frame * m_TexData.imageSize; + data += CalculateMipMapOffset (m_TexData.width, m_TexData.height, m_TexData.format, miplevel); + int dataWidth = std::max (m_TexData.width >> miplevel, 1); + int dataHeight = std::max (m_TexData.height >> miplevel, 1); + + SetImagePixelBlock (data, dataWidth, dataHeight, m_TexData.format, x, y, width, height, pixelCount, pixels); +} + + + +ColorRGBAf Texture2D::GetPixel (int frame,int x, int y) const +{ + if (!CheckHasPixelData()) + return ColorRGBAf(1.0F,1.0F,1.0F,1.0F); + + if (frame > m_ImageCount) { + ErrorString (Format ("GetPixel called on an undefined image (valid values are 0 - %d", m_ImageCount - 1)); + return ColorRGBAf(1.0F,1.0F,1.0F,1.0F); + } + + return GetImagePixel (m_TexData.data + frame*m_TexData.imageSize, m_TexData.width, m_TexData.height, m_TexData.format, static_cast<TextureWrapMode>(GetSettings().m_WrapMode), x, y); +} + +ColorRGBAf Texture2D::GetPixelBilinear (int frame, float u, float v) const +{ + if (!CheckHasPixelData()) + return ColorRGBAf(1.0F,1.0F,1.0F,1.0F); + if (frame > m_ImageCount) { + ErrorString (Format ("GetPixelBilinear called on an undefined image (valid values are 0 - %d", m_ImageCount - 1)); + return ColorRGBAf(1.0F,1.0F,1.0F,1.0F); + } + return GetImagePixelBilinear (m_TexData.data + frame*m_TexData.imageSize, m_TexData.width, m_TexData.height, m_TexData.format, static_cast<TextureWrapMode>(GetSettings().m_WrapMode), u, v); +} + +bool Texture2D::GetPixels( int x, int y, int width, int height, int miplevel, ColorRGBAf* colors, int frame ) const +{ + if (width == 0 || height == 0) + return true; // nothing to do + + if (!CheckHasPixelData()) + return false; + + int mipcount = CountMipmaps(); + if (miplevel < 0 || miplevel >= mipcount) + { + ErrorString ("Invalid mip level"); + return false; + } + + UInt8* data = m_TexData.data + frame * m_TexData.imageSize; + data += CalculateMipMapOffset (m_TexData.width, m_TexData.height, m_TexData.format, miplevel); + int dataWidth = std::max (m_TexData.width >> miplevel, 1); + int dataHeight = std::max (m_TexData.height >> miplevel, 1); + + return GetImagePixelBlock (data, dataWidth, dataHeight, m_TexData.format, x, y, width, height, colors); +} + +bool Texture2D::GetPixels32( int miplevel, ColorRGBA32* colors ) const +{ + AssertIf( miplevel < 0 || miplevel >= CountDataMipmaps() ); + + ImageReference texImage; + if( !GetImageReferenceInternal(&texImage, 0, miplevel) ) + { + if (m_TexData.data != NULL && IsAnyCompressedTextureFormat(m_TexData.format)) + { + UInt8* data = m_TexData.data + CalculateMipMapOffset( m_TexData.width, m_TexData.height, m_TexData.format, miplevel ); + const int minSize = GetMinimumTextureMipSizeForFormat(m_TexData.format); + // the decompress size is at least minSize x minSize + int width = std::max (m_TexData.width >> miplevel, minSize); + int height = std::max (m_TexData.height >> miplevel, minSize); + // also, it should be a multiple of minSize + if (width % minSize == 0 && height % minSize == 0) + { + DecompressNativeTextureFormatWithMipLevel( m_TexData.format, width, height,miplevel, reinterpret_cast<const UInt32*>(data), width, height, reinterpret_cast<UInt32*>(colors) ); + return true; + } + else + { + // make it an upper multiple of minSize + int decompWidth = (width + minSize - 1) / minSize * minSize; + int decompHeight = (height + minSize - 1) / minSize * minSize; + Image decompressed( decompWidth, decompHeight, kTexFormatRGBA32 ); + DecompressNativeTextureFormatWithMipLevel( m_TexData.format, width, height,miplevel, reinterpret_cast<const UInt32*>(data), decompWidth, decompHeight, (UInt32*)decompressed.GetImageData() ); + // clip it back to the original size + ImageReference clipped = decompressed.ClipImage( 0, 0, width, height ); + // blit it over to the colors array + ImageReference resultImage( width, height, GetRowBytesFromWidthAndFormat(width,kTexFormatRGBA32), kTexFormatRGBA32, colors ); + resultImage.BlitImage( clipped, ImageReference::BLIT_COPY ); + return true; + } + } + AssertString( "Invalid texture" ); + return false; + } + + int texWidth = texImage.GetWidth(); + int texHeight = texImage.GetHeight(); + + ImageReference resultImage( texWidth, texHeight, GetRowBytesFromWidthAndFormat(texWidth,kTexFormatRGBA32), kTexFormatRGBA32, colors ); + resultImage.BlitImage( texImage, ImageReference::BLIT_COPY ); + + return true; +} + + +void Texture2D::SetPixels32( int miplevel, const ColorRGBA32* pixels, const int pixelCount ) +{ + AssertIf( miplevel < 0 || miplevel >= CountMipmaps() ); + + ImageReference texImage; + if( !GetWriteImageReference(&texImage, 0, miplevel) ) + { + AssertString( "Invalid texture format" ); + return; + } + + int texWidth = texImage.GetWidth(); + int texHeight = texImage.GetHeight(); + + if(texWidth * texHeight != pixelCount) + { + AssertString( "SetPixels32 called with invalid number if pixels in the array" ); + return; + } + + ImageReference inputImage( texWidth, texHeight, GetRowBytesFromWidthAndFormat(texWidth,kTexFormatRGBA32), kTexFormatRGBA32, (void*)pixels ); + texImage.BlitImage( inputImage, ImageReference::BLIT_COPY ); +} + +static const char* kUnsupportedColorPixelFormatMessage = "Unsupported image format - the texture needs to be ARGB32 or RGB24"; + +static bool IsAllowedToReadPixels () +{ +#if UNITY_EDITOR + // from Player.h + bool IsInsidePlayerLoop (); + // Editor needs to read frame buffer outside player loop + if( !IsInsidePlayerLoop() ) + return true; +#elif WEBPLUG + // Allow old web content for compatibility + if( !IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_0_a1) ) + return true; +#endif + return GetGfxDevice().IsInsideFrame() || RenderTexture::GetActive(); +} + +// TODO: Check dimensions, make everything work. +void Texture2D::ReadPixels (int frame, int left, int bottom, int width, int height, int destX, int destY, bool flipped, bool computeMipMap) +{ + //Prevent out of bounds reads (case 562067) + if (destX < 0 || destY < 0 || destX >= GetDataWidth() || destY >= GetDataHeight()) + { + ErrorString("Trying to read pixels out of bounds"); + return; + } + if (width < 0 || height < 0) + { + ErrorString("Negative read pixels rectangle width|height"); + return; + } + + if( !IsAllowedToReadPixels() ) + { + ErrorString ("ReadPixels was called to read pixels from system frame buffer, while not inside drawing frame."); + // Our tests rely on calling ReadImage() during Update() so we allow it anyway... + } + + if( frame >= m_ImageCount ) + { + ErrorString (Format ("ReadPixels called on undefined image %d (valid values are 0 - %d", frame, m_ImageCount - 1)); + return; + } + + GfxDeviceRenderer renderer = GetGfxDevice().GetRenderer(); + bool isGLES = (renderer == kGfxRendererOpenGLES20Mobile || renderer == kGfxRendererOpenGLES30); + int texFormat = GetTextureFormat(); + bool validFormat = texFormat == kTexFormatARGB32 || + texFormat == kTexFormatRGB24 || + texFormat == (kTexFormatRGBA32 && isGLES) || + texFormat == (kTexFormatRGB565 && isGLES); + if( !validFormat ) + { + ErrorString(kUnsupportedColorPixelFormatMessage); + return; + } + + ImageReference image; + if( !GetWriteImageReference(&image, frame, 0) ) + { + ErrorString("Unable to retrieve image reference"); + return; + } + + if (RenderTexture::GetActive() == NULL) + { + Rectf rc = GetRenderManager().GetWindowRect(); + left += rc.x; + bottom += rc.y; + } + + if (left < 0) { + width += left; + left = 0; + } + if (bottom < 0) { + height += bottom; + bottom = 0; + } + if (destX + width > GetDataWidth()) + width = GetDataWidth() - destX; + if (destY + height > GetDataHeight()) + height = GetDataHeight() - destY; + + GetGfxDevice().ReadbackImage( image, left, bottom, width, height, destX, destY ); + + if (flipped) + { + ImageReference subImage = image.ClipImage (destX, destY, width, height); + subImage.FlipImageY(); + } + + if( computeMipMap && m_MipMap ) + RebuildMipMap(); +} + + +#if ENABLE_PNG_JPG +bool Texture2D::EncodeToPNG( dynamic_array<UInt8>& outBuffer ) +{ + if( IsAnyCompressedTextureFormat(GetTextureFormat()) ) + { + ErrorString(kUnsupportedSetPixelOpFormatMessage); + return false; + } + ImageReference image; + if( !GetWriteImageReference( &image, 0, 0 ) ) + { + ErrorString( "Unable to retrieve image reference" ); + return false; + } + if( !ConvertImageToPNGBuffer( image, outBuffer ) ) + { + ErrorString( "Failed to encode to PNG" ); + return false; + } + + return true; +} +#endif + + + +bool Texture2D::ResizeWithFormat (int width, int height, TextureFormat format, int flags) +{ + if (!m_IsReadable) + { + ErrorString ("Texture is not readable."); + return false; + } + + if( IsAnyCompressedTextureFormat(format) ) + { + ErrorStringObject ("Can't resize to a compressed texture format", this); + return false; + } + + return InitTexture(width, height, format, flags); +} + + +void Texture2D::Compress (bool dither) +{ + if (!m_IsReadable) + { + ErrorString(Format("Texture '%s' is not readable, Compress will not work. You can make the texture readable in the Texture Import Settings.", GetName())); + return; + } + + SET_ALLOC_OWNER(this); + // If hardware does not support DXT, then nothing to do. + if( !gGraphicsCaps.hasS3TCCompression ) + return; + + #if !GFX_SUPPORTS_DXT_COMPRESSION + Assert(!"GraphicsCaps.hasS3TCCompression is invalid"); + return; + #else + + TextureFormat format = GetTextureFormat(); + // If already compressed, then nothing to do. + if( IsAnyCompressedTextureFormat(format) ) + return; + + // Copy out old data into RGBA32 format. + bool mipMaps = HasMipMap(); + int width = GetDataWidth(); + int height = GetDataHeight(); + int rgbaByteSize = mipMaps ? + CalculateImageMipMapSize( width, height, kTexFormatRGBA32 ) : + CalculateImageSize( width, height, kTexFormatRGBA32 ); + UInt8* rgbaData = new UInt8[rgbaByteSize]; + int mipCount = CountDataMipmaps(); + for( int mip = 0; mip < mipCount; ++mip ) + { + UInt8* rgbaMipData = rgbaData + CalculateMipMapOffset(width, height, kTexFormatRGBA32, mip); + int mipWidth = std::max( width >> mip, 1 ); + int mipHeight = std::max( height >> mip, 1 ); + ImageReference mipDst( mipWidth, mipHeight, mipWidth * 4, kTexFormatRGBA32, rgbaMipData ); + ExtractImageInternal( &mipDst, false, 0 ); + } + + // Reformat texture into DXT format + bool hasAlpha = HasAlphaTextureFormat(format); + TextureFormat compressedFormat = hasAlpha ? kTexFormatDXT5 : kTexFormatDXT1; + InitTexture( width, height, compressedFormat, mipMaps ? kMipmapMask : kNoMipmap ); + + // DXT compress RGBA data + for( int mip = 0; mip < mipCount; ++mip ) + { + const UInt8* srcMipData = rgbaData + CalculateMipMapOffset(width, height, kTexFormatRGBA32, mip); + UInt8* dstMipData = GetRawImageData() + CalculateMipMapOffset(width, height, compressedFormat, mip); + int mipWidth = std::max( width >> mip, 1 ); + int mipHeight = std::max( height >> mip, 1 ); + FastCompressImage( mipWidth, mipHeight, srcMipData, dstMipData, hasAlpha, dither ); + } + + delete[] rgbaData; + + UpdateImageDataDontTouchMipmap(); + #endif //GFX_SUPPORTS_DXT_COMPRESSION +} + +#if UNITY_EDITOR +void Texture2D::WarnInstantiateDisallowed () +{ + if (!m_IsReadable) + { + ErrorStringObject(Format("Instantiating a non-readable '%s' texture is not allowed! Please mark the texture readable in the inspector or don't instantiate it.", GetName()), this); + } +} + +bool Texture2D::IgnoreMasterTextureLimit () const +{ + return m_IgnoreMasterTextureLimit; +} + +void Texture2D::SetIgnoreMasterTextureLimit (bool ignore) +{ + m_IgnoreMasterTextureLimit = ignore; +} + +bool Texture2D::GetAlphaIsTransparency() const +{ + return m_AlphaIsTransparency; +} + +void Texture2D::SetAlphaIsTransparency(bool is) +{ + m_AlphaIsTransparency = is; +} +#endif // UNITY_EDITOR + + +void Texture2D::Apply(bool updateMipmaps, bool makeNoLongerReadable) +{ + if( makeNoLongerReadable ) + { + SetIsReadable(false); + SetIsUnreloadable(true); + } + + if( IsAnyCompressedTextureFormat(GetTextureFormat()) ) + updateMipmaps = false; + + if (updateMipmaps) UpdateImageData(); + else UpdateImageDataDontTouchMipmap(); +} + + |