[windows] Use unsigned for enums used as bitfields

When using enums as bitfields, the Microsoft C++ compiler will generated
shift intructions to when comparing the enum with one of its constants.
As by default enums are signed interegers, the compiler will generated
signed shifts, yielding trash values.

We define the enums in the TextureInfo class as unsigned ints to avoid
this bug.

Change-Id: Icdd49c3b417b09313964c71381b7c8230c844f12

diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.cpp b/dali-toolkit/internal/visuals/texture-manager-impl.cpp
index 5e0b506..00b8eca 100644 (file)
--- a/dali-toolkit/internal/visuals/texture-manager-impl.cpp
+++ b/dali-toolkit/internal/visuals/texture-manager-impl.cpp
@@ -82,15 +82,15 @@ namespace
 Debug::Filter* gTextureManagerLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_TEXTURE_MANAGER" );
 
 #define GET_LOAD_STATE_STRING( loadState ) \
-  loadState == TextureManager::NOT_STARTED ? "NOT_STARTED" :             \
-    loadState == TextureManager::LOADING ? "LOADING" :                   \
-    loadState == TextureManager::LOAD_FINISHED ? "LOAD_FINISHED" :       \
-    loadState == TextureManager::WAITING_FOR_MASK ? "WAITING_FOR_MASK" : \
-    loadState == TextureManager::MASK_APPLYING ? "MASK_APPLYING" :         \
-    loadState == TextureManager::MASK_APPLIED ? "MASK_APPLIED" :         \
-    loadState == TextureManager::UPLOADED ? "UPLOADED" :                 \
-    loadState == TextureManager::CANCELLED ? "CANCELLED" :               \
-    loadState == TextureManager::LOAD_FAILED ? "LOAD_FAILED" : "Unknown"
+  loadState == TextureManager::LoadState::NOT_STARTED ? "NOT_STARTED" :             \
+    loadState == TextureManager::LoadState::LOADING ? "LOADING" :                   \
+    loadState == TextureManager::LoadState::LOAD_FINISHED ? "LOAD_FINISHED" :       \
+    loadState == TextureManager::LoadState::WAITING_FOR_MASK ? "WAITING_FOR_MASK" : \
+    loadState == TextureManager::LoadState::MASK_APPLYING ? "MASK_APPLYING" :         \
+    loadState == TextureManager::LoadState::MASK_APPLIED ? "MASK_APPLIED" :         \
+    loadState == TextureManager::LoadState::UPLOADED ? "UPLOADED" :                 \
+    loadState == TextureManager::LoadState::CANCELLED ? "CANCELLED" :               \
+    loadState == TextureManager::LoadState::LOAD_FAILED ? "LOAD_FAILED" : "Unknown"
 
 #endif
 
@@ -192,10 +192,10 @@ TextureSet TextureManager::LoadAnimatedImageTexture(
   {
     auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
     textureId = RequestLoadInternal( animatedImageLoading.GetUrl(), INVALID_TEXTURE_ID, 1.0f, ImageDimensions(), FittingMode::SCALE_TO_FILL,
-                                     SamplingMode::BOX_THEN_LINEAR, TextureManager::NO_ATLAS, false, UPLOAD_TO_TEXTURE, textureObserver,
+                                     SamplingMode::BOX_THEN_LINEAR, TextureManager::NO_ATLAS, false, StorageType::UPLOAD_TO_TEXTURE, textureObserver,
                                      true, TextureManager::ReloadPolicy::CACHED, preMultiply, animatedImageLoading, frameIndex );
     TextureManager::LoadState loadState = GetTextureStateInternal( textureId );
-    if( loadState == TextureManager::UPLOADED )
+    if( loadState == TextureManager::LoadState::UPLOADED )
     {
       // UploadComplete has already been called - keep the same texture set
       textureSet = GetTextureSet( textureId );
@@ -231,7 +231,7 @@ Devel::PixelBuffer TextureManager::LoadPixelBuffer(
   else
   {
     RequestLoadInternal( url, INVALID_TEXTURE_ID, 1.0f, desiredSize, fittingMode, samplingMode, TextureManager::NO_ATLAS,
-                         false, RETURN_PIXEL_BUFFER, textureObserver, orientationCorrection, TextureManager::ReloadPolicy::FORCED,
+                         false, StorageType::RETURN_PIXEL_BUFFER, textureObserver, orientationCorrection, TextureManager::ReloadPolicy::FORCED,
                          preMultiplyOnLoad, Dali::AnimatedImageLoading(), 0u );
   }
 
@@ -359,7 +359,7 @@ TextureSet TextureManager::LoadTexture(
       }
 
       TextureManager::LoadState loadState = GetTextureStateInternal( textureId );
-      if( loadState == TextureManager::UPLOADED )
+      if( loadState == TextureManager::LoadState::UPLOADED )
       {
         // UploadComplete has already been called - keep the same texture set
         textureSet = GetTextureSet( textureId );
@@ -367,11 +367,11 @@ TextureSet TextureManager::LoadTexture(
 
       // If we are loading the texture, or waiting for the ready signal handler to complete, inform
       // caller that they need to wait.
-      loadingStatus = ( loadState == TextureManager::LOADING ||
-                        loadState == TextureManager::WAITING_FOR_MASK ||
-                        loadState == TextureManager::MASK_APPLYING ||
-                        loadState == TextureManager::MASK_APPLIED ||
-                        loadState == TextureManager::NOT_STARTED ||
+      loadingStatus = ( loadState == TextureManager::LoadState::LOADING ||
+                        loadState == TextureManager::LoadState::WAITING_FOR_MASK ||
+                        loadState == TextureManager::LoadState::MASK_APPLYING ||
+                        loadState == TextureManager::LoadState::MASK_APPLIED ||
+                        loadState == TextureManager::LoadState::NOT_STARTED ||
                         mQueueLoadFlag );
 
     }
@@ -403,7 +403,7 @@ TextureManager::TextureId TextureManager::RequestLoad(
   TextureManager::MultiplyOnLoad& preMultiplyOnLoad )
 {
   return RequestLoadInternal( url, INVALID_TEXTURE_ID, 1.0f, desiredSize, fittingMode, samplingMode, useAtlas,
-                              false, UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
+                              false, StorageType::UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
                               preMultiplyOnLoad, Dali::AnimatedImageLoading(), 0u );
 }
 
@@ -422,7 +422,7 @@ TextureManager::TextureId TextureManager::RequestLoad(
   TextureManager::MultiplyOnLoad& preMultiplyOnLoad )
 {
   return RequestLoadInternal( url, maskTextureId, contentScale, desiredSize, fittingMode, samplingMode, useAtlas,
-                              cropToMask, UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
+                              cropToMask, StorageType::UPLOAD_TO_TEXTURE, observer, orientationCorrection, reloadPolicy,
                               preMultiplyOnLoad, Dali::AnimatedImageLoading(), 0u );
 }
 
@@ -431,7 +431,7 @@ TextureManager::TextureId TextureManager::RequestMaskLoad( const VisualUrl& mask
   // Use the normal load procedure to get the alpha mask.
   auto preMultiply = TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
   return RequestLoadInternal( maskUrl, INVALID_TEXTURE_ID, 1.0f, ImageDimensions(), FittingMode::SCALE_TO_FILL,
-                              SamplingMode::NO_FILTER, NO_ATLAS, false, KEEP_PIXEL_BUFFER, NULL, true,
+                              SamplingMode::NO_FILTER, NO_ATLAS, false, StorageType::KEEP_PIXEL_BUFFER, NULL, true,
                               TextureManager::ReloadPolicy::CACHED, preMultiply, Dali::AnimatedImageLoading(), 0u );
 }
 
@@ -508,37 +508,37 @@ TextureManager::TextureId TextureManager::RequestLoadInternal(
 
   // Force reloading of texture by setting loadState unless already loading or cancelled.
   if ( TextureManager::ReloadPolicy::FORCED == reloadPolicy &&
-       TextureManager::LOADING != textureInfo.loadState &&
-       TextureManager::WAITING_FOR_MASK != textureInfo.loadState &&
-       TextureManager::MASK_APPLYING != textureInfo.loadState &&
-       TextureManager::MASK_APPLIED != textureInfo.loadState &&
-       TextureManager::CANCELLED != textureInfo.loadState )
+       TextureManager::LoadState::LOADING != textureInfo.loadState &&
+       TextureManager::LoadState::WAITING_FOR_MASK != textureInfo.loadState &&
+       TextureManager::LoadState::MASK_APPLYING != textureInfo.loadState &&
+       TextureManager::LoadState::MASK_APPLIED != textureInfo.loadState &&
+       TextureManager::LoadState::CANCELLED != textureInfo.loadState )
   {
     DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Verbose, "TextureManager::RequestLoad( url=%s observer=%p ) ForcedReload cacheIndex:%d, textureId=%d\n",
                    url.GetUrl().c_str(), observer, cacheIndex, textureId );
 
-    textureInfo.loadState = TextureManager::NOT_STARTED;
+    textureInfo.loadState = TextureManager::LoadState::NOT_STARTED;
   }
 
   // Check if we should add the observer.
   // Only do this if we have not loaded yet and it will not have loaded by the end of this method.
   switch( textureInfo.loadState )
   {
-    case TextureManager::LOAD_FAILED: // Failed notifies observer which then stops observing.
-    case TextureManager::NOT_STARTED:
+    case TextureManager::LoadState::LOAD_FAILED: // Failed notifies observer which then stops observing.
+    case TextureManager::LoadState::NOT_STARTED:
     {
       LoadOrQueueTexture( textureInfo, observer ); // If called inside NotifyObservers, queues until afterwards
       break;
     }
-    case TextureManager::LOADING:
-    case TextureManager::WAITING_FOR_MASK:
-    case TextureManager::MASK_APPLYING:
-    case TextureManager::MASK_APPLIED:
+    case TextureManager::LoadState::LOADING:
+    case TextureManager::LoadState::WAITING_FOR_MASK:
+    case TextureManager::LoadState::MASK_APPLYING:
+    case TextureManager::LoadState::MASK_APPLIED:
     {
       ObserveTexture( textureInfo, observer );
       break;
     }
-    case TextureManager::UPLOADED:
+    case TextureManager::LoadState::UPLOADED:
     {
       if( observer )
       {
@@ -546,15 +546,15 @@ TextureManager::TextureId TextureManager::RequestLoadInternal(
       }
       break;
     }
-    case TextureManager::CANCELLED:
+    case TextureManager::LoadState::CANCELLED:
     {
       // A cancelled texture hasn't finished loading yet. Treat as a loading texture
       // (it's ref count has already been incremented, above)
-      textureInfo.loadState = TextureManager::LOADING;
+      textureInfo.loadState = TextureManager::LoadState::LOADING;
       ObserveTexture( textureInfo, observer );
       break;
     }
-    case TextureManager::LOAD_FINISHED:
+    case TextureManager::LoadState::LOAD_FINISHED:
     {
       // Loading has already completed.
       if( observer && textureInfo.storageType == StorageType::RETURN_PIXEL_BUFFER )
@@ -589,7 +589,7 @@ void TextureManager::Remove( const TextureManager::TextureId textureId, TextureU
       bool removeTextureInfo = false;
 
       // If loaded, we can remove the TextureInfo and the Atlas (if atlased).
-      if( textureInfo.loadState == UPLOADED )
+      if( textureInfo.loadState == LoadState::UPLOADED )
       {
         if( textureInfo.atlas )
         {
@@ -597,11 +597,11 @@ void TextureManager::Remove( const TextureManager::TextureId textureId, TextureU
         }
         removeTextureInfo = true;
       }
-      else if( textureInfo.loadState == LOADING )
+      else if( textureInfo.loadState == LoadState::LOADING )
       {
         // We mark the textureInfo for removal.
         // Once the load has completed, this method will be called again.
-        textureInfo.loadState = CANCELLED;
+        textureInfo.loadState = LoadState::CANCELLED;
       }
       else
       {
@@ -650,7 +650,7 @@ VisualUrl TextureManager::GetVisualUrl( TextureId textureId )
 
 TextureManager::LoadState TextureManager::GetTextureState( TextureId textureId )
 {
-  LoadState loadState = TextureManager::NOT_STARTED;
+  LoadState loadState = TextureManager::LoadState::NOT_STARTED;
 
   int cacheIndex = GetCacheIndexFromId( textureId );
   if( cacheIndex != INVALID_CACHE_INDEX )
@@ -674,7 +674,7 @@ TextureManager::LoadState TextureManager::GetTextureState( TextureId textureId )
 
 TextureManager::LoadState TextureManager::GetTextureStateInternal( TextureId textureId )
 {
-  LoadState loadState = TextureManager::NOT_STARTED;
+  LoadState loadState = TextureManager::LoadState::NOT_STARTED;
 
   int cacheIndex = GetCacheIndexFromId( textureId );
   if( cacheIndex != INVALID_CACHE_INDEX )
@@ -774,8 +774,8 @@ void TextureManager::LoadOrQueueTexture( TextureInfo& textureInfo, TextureUpload
 {
   switch( textureInfo.loadState )
   {
-    case NOT_STARTED:
-    case LOAD_FAILED:
+    case LoadState::NOT_STARTED:
+    case LoadState::LOAD_FAILED:
     {
       if( mQueueLoadFlag )
       {
@@ -787,7 +787,7 @@ void TextureManager::LoadOrQueueTexture( TextureInfo& textureInfo, TextureUpload
       }
       break;
     }
-    case UPLOADED:
+    case LoadState::UPLOADED:
     {
       if( mQueueLoadFlag )
       {
@@ -803,12 +803,12 @@ void TextureManager::LoadOrQueueTexture( TextureInfo& textureInfo, TextureUpload
       }
       break;
     }
-    case LOADING:
-    case CANCELLED:
-    case LOAD_FINISHED:
-    case WAITING_FOR_MASK:
-    case MASK_APPLYING:
-    case MASK_APPLIED:
+    case LoadState::LOADING:
+    case LoadState::CANCELLED:
+    case LoadState::LOAD_FINISHED:
+    case LoadState::WAITING_FOR_MASK:
+    case LoadState::MASK_APPLYING:
+    case LoadState::MASK_APPLIED:
     {
       break;
     }
@@ -828,7 +828,7 @@ void TextureManager::LoadTexture( TextureInfo& textureInfo, TextureUploadObserve
   DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "TextureManager::LoadTexture(): url:%s sync:%s\n",
                  textureInfo.url.GetUrl().c_str(), textureInfo.loadSynchronously?"T":"F" );
 
-  textureInfo.loadState = LOADING;
+  textureInfo.loadState = LoadState::LOADING;
   if( !textureInfo.loadSynchronously )
   {
     auto& loadersContainer = textureInfo.url.IsLocalResource() ? mAsyncLocalLoaders : mAsyncRemoteLoaders;
@@ -864,13 +864,13 @@ void TextureManager::ProcessQueuedTextures()
     if( cacheIndex != INVALID_CACHE_INDEX )
     {
       TextureInfo& textureInfo( mTextureInfoContainer[cacheIndex] );
-      if( textureInfo.loadState == UPLOADED )
+      if( textureInfo.loadState == LoadState::UPLOADED )
       {
         element.mObserver->UploadComplete( true, textureInfo.textureId, textureInfo.textureSet,
                                            textureInfo.useAtlas, textureInfo.atlasRect,
                                            textureInfo.preMultiplied );
       }
-      else if ( textureInfo.loadState == LOAD_FINISHED && textureInfo.storageType == StorageType::RETURN_PIXEL_BUFFER )
+      else if ( textureInfo.loadState == LoadState::LOAD_FINISHED && textureInfo.storageType == StorageType::RETURN_PIXEL_BUFFER )
       {
         element.mObserver->LoadComplete( true, textureInfo.pixelBuffer, textureInfo.url, textureInfo.preMultiplied );
       }
@@ -916,7 +916,7 @@ void TextureManager::AsyncLoadComplete( AsyncLoadingInfoContainerType& loadingCo
                        "  textureId:%d Url:%s CacheIndex:%d LoadState: %d\n",
                        textureInfo.textureId, textureInfo.url.GetUrl().c_str(), cacheIndex, textureInfo.loadState );
 
-        if( textureInfo.loadState != CANCELLED )
+        if( textureInfo.loadState != LoadState::CANCELLED )
         {
           // textureInfo can be invalidated after this call (as the mTextureInfoContainer may be modified)
           PostLoad( textureInfo, pixelBuffer );
@@ -941,16 +941,16 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
     textureInfo.useAtlas = NO_ATLAS;
     textureInfo.preMultiplied = pixelBuffer.IsAlphaPreMultiplied();
 
-    if( textureInfo.storageType == UPLOAD_TO_TEXTURE )
+    if( textureInfo.storageType == StorageType::UPLOAD_TO_TEXTURE )
     {
       // If there is a mask texture ID associated with this texture, then apply the mask
       // if it's already loaded. If it hasn't, and the mask is still loading,
       // wait for the mask to finish loading.
       if( textureInfo.maskTextureId != INVALID_TEXTURE_ID )
       {
-        if( textureInfo.loadState == MASK_APPLYING )
+        if( textureInfo.loadState == LoadState::MASK_APPLYING )
         {
-          textureInfo.loadState = MASK_APPLIED;
+          textureInfo.loadState = LoadState::MASK_APPLIED;
           UploadTexture( pixelBuffer, textureInfo );
           NotifyObservers( textureInfo, true );
         }
@@ -958,11 +958,11 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
         {
           LoadState maskLoadState = GetTextureStateInternal( textureInfo.maskTextureId );
           textureInfo.pixelBuffer = pixelBuffer; // Store the pixel buffer temporarily
-          if( maskLoadState == LOADING )
+          if( maskLoadState == LoadState::LOADING )
           {
-            textureInfo.loadState = WAITING_FOR_MASK;
+            textureInfo.loadState = LoadState::WAITING_FOR_MASK;
           }
-          else if( maskLoadState == LOAD_FINISHED )
+          else if( maskLoadState == LoadState::LOAD_FINISHED )
           {
             // Send New Task to Thread
             ApplyMask( textureInfo, textureInfo.maskTextureId );
@@ -978,7 +978,7 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
     else
     {
       textureInfo.pixelBuffer = pixelBuffer; // Store the pixel data
-      textureInfo.loadState = LOAD_FINISHED;
+      textureInfo.loadState = LoadState::LOAD_FINISHED;
 
       if( textureInfo.storageType == StorageType::RETURN_PIXEL_BUFFER )
       {
@@ -995,7 +995,7 @@ void TextureManager::PostLoad( TextureInfo& textureInfo, Devel::PixelBuffer& pix
   else
   {
     // @todo If the load was unsuccessful, upload the broken image.
-    textureInfo.loadState = LOAD_FAILED;
+    textureInfo.loadState = LoadState::LOAD_FAILED;
     CheckForWaitingTexture( textureInfo );
     NotifyObservers( textureInfo, false );
   }
@@ -1010,11 +1010,11 @@ void TextureManager::CheckForWaitingTexture( TextureInfo& maskTextureInfo )
   for( unsigned int cacheIndex = 0; cacheIndex < size; ++cacheIndex )
   {
     if( mTextureInfoContainer[cacheIndex].maskTextureId == maskTextureInfo.textureId &&
-        mTextureInfoContainer[cacheIndex].loadState == WAITING_FOR_MASK )
+        mTextureInfoContainer[cacheIndex].loadState == LoadState::WAITING_FOR_MASK )
     {
       TextureInfo& textureInfo( mTextureInfoContainer[cacheIndex] );
 
-      if( maskTextureInfo.loadState == LOAD_FINISHED )
+      if( maskTextureInfo.loadState == LoadState::LOAD_FINISHED )
       {
         // Send New Task to Thread
         ApplyMask( textureInfo, maskTextureInfo.textureId );
@@ -1022,7 +1022,7 @@ void TextureManager::CheckForWaitingTexture( TextureInfo& maskTextureInfo )
       else
       {
         textureInfo.pixelBuffer.Reset();
-        textureInfo.loadState = LOAD_FAILED;
+        textureInfo.loadState = LoadState::LOAD_FAILED;
         NotifyObservers( textureInfo, false );
       }
     }
@@ -1041,7 +1041,7 @@ void TextureManager::ApplyMask( TextureInfo& textureInfo, TextureId maskTextureI
     DALI_LOG_INFO( gTextureManagerLogFilter, Debug::Concise, "TextureManager::ApplyMask(): url:%s sync:%s\n",
                    textureInfo.url.GetUrl().c_str(), textureInfo.loadSynchronously?"T":"F" );
 
-    textureInfo.loadState = MASK_APPLYING;
+    textureInfo.loadState = LoadState::MASK_APPLYING;
     auto& loadersContainer = textureInfo.url.IsLocalResource() ? mAsyncLocalLoaders : mAsyncRemoteLoaders;
     auto loadingHelperIt = loadersContainer.GetNext();
     auto premultiplyOnLoad = textureInfo.preMultiplyOnLoad ? DevelAsyncImageLoader::PreMultiplyOnLoad::ON : DevelAsyncImageLoader::PreMultiplyOnLoad::OFF;
@@ -1081,7 +1081,7 @@ void TextureManager::UploadTexture( Devel::PixelBuffer& pixelBuffer, TextureInfo
   // Note: This is regardless of success as we care about whether a
   // load attempt is in progress or not.  If unsuccessful, a broken
   // image is still loaded.
-  textureInfo.loadState = UPLOADED;
+  textureInfo.loadState = LoadState::UPLOADED;
 }
 
 void TextureManager::NotifyObservers( TextureInfo& textureInfo, bool success )
@@ -1194,7 +1194,7 @@ TextureManager::TextureHash TextureManager::GenerateHash(
 
     // Bit-pack the FittingMode, SamplingMode and atlasing.
     // FittingMode=2bits, SamplingMode=3bits, useAtlas=1bit, storageType=2bits
-    *hashTargetPtr   = ( fittingMode << 6u ) | ( samplingMode << 3 ) | ( useAtlas << 2 ) | storageType;
+    *hashTargetPtr   = ( fittingMode << 6u ) | ( samplingMode << 3 ) | ( useAtlas << 2 ) | static_cast<unsigned int>(storageType);
   }
   else
   {

diff --git a/dali-toolkit/internal/visuals/texture-manager-impl.h b/dali-toolkit/internal/visuals/texture-manager-impl.h
index f8500c7..89afd47 100644 (file)
--- a/dali-toolkit/internal/visuals/texture-manager-impl.h
+++ b/dali-toolkit/internal/visuals/texture-manager-impl.h
@@ -76,7 +76,7 @@ public:
   /**
    * Whether the pixel data should be kept in TextureManager, returned with pixelBuffer or uploaded for rendering
    */
-  enum StorageType
+  enum class StorageType: uint8_t
   {
     KEEP_PIXEL_BUFFER,
     RETURN_PIXEL_BUFFER,
@@ -86,7 +86,7 @@ public:
   /**
    * Whether the texture should be loaded synchronously or asynchronously.
    */
-  enum LoadType
+  enum class LoadType: uint8_t
   {
     LOAD_ASYNCHRONOUSLY,
     LOAD_SYNCHRONOUSLY
@@ -95,7 +95,7 @@ public:
   /**
    * @brief The LoadState Enumeration represents the current state of a particular Texture's life-cycle.
    */
-  enum LoadState
+  enum class LoadState: uint8_t
   {
     NOT_STARTED,     ///< Default
     LOADING,         ///< Loading has been started, but not finished.
@@ -530,10 +530,10 @@ private:
       hash( hash ),
       scaleFactor( scaleFactor ),
       referenceCount( 1u ),
-      loadState( NOT_STARTED ),
+      loadState( LoadState::NOT_STARTED ),
       fittingMode( fittingMode ),
       samplingMode( samplingMode ),
-      storageType( UPLOAD_TO_TEXTURE ),
+      storageType( StorageType::UPLOAD_TO_TEXTURE ),
       animatedImageLoading( animatedImageLoading ),
       frameIndex( frameIndex ),
       loadSynchronously( loadSynchronously ),
@@ -563,10 +563,10 @@ private:
     TextureManager::TextureHash hash; ///< The hash used to cache this Texture
     float scaleFactor;             ///< The scale factor to apply to the Texture when masking
     int16_t referenceCount;        ///< The reference count of clients using this Texture
-    LoadState loadState:4;         ///< The load state showing the load progress of the Texture
+    LoadState loadState;           ///< The load state showing the load progress of the Texture
     FittingMode::Type fittingMode:3; ///< The requested FittingMode
     Dali::SamplingMode::Type samplingMode:3; ///< The requested SamplingMode
-    StorageType storageType:2;     ///< CPU storage / GPU upload;
+    StorageType storageType;       ///< CPU storage / GPU upload;
     Dali::AnimatedImageLoading animatedImageLoading; ///< AnimatedImageLoading that contains animated image information.
     uint32_t frameIndex;           ///< frame index that be loaded, in case of animated image
     bool loadSynchronously:1;      ///< True if synchronous loading was requested