dali-toolkit/internal/visuals/image-atlas-manager.cpp

   1  /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "image-atlas-manager.h"
  20
  21 // EXTERNAL HEADER
  22 #include <dali/devel-api/images/texture-set-image.h>
  23 #include <dali/devel-api/adaptor-framework/image-loading.h>
  24
  25 namespace Dali
  26 {
  27
  28 namespace Toolkit
  29 {
  30
  31 namespace Internal
  32 {
  33
  34 namespace
  35 {
  36 const uint32_t DEFAULT_ATLAS_SIZE( 1024u ); // this size can fit 8 by 8 images of average size 128*128
  37 const uint32_t MAX_ITEM_SIZE( 512u  );
  38 const uint32_t MAX_ITEM_AREA( MAX_ITEM_SIZE*MAX_ITEM_SIZE  );
  39 }
  40
  41 ImageAtlasManager::ImageAtlasManager()
  42 : mBrokenImageUrl( "" )
  43 {
  44 }
  45
  46 ImageAtlasManager::~ImageAtlasManager()
  47 {
  48 }
  49
  50 TextureSet ImageAtlasManager::Add( Vector4& textureRect,
  51                                  const std::string& url,
  52                                  ImageDimensions& size,
  53                                  FittingMode::Type fittingMode,
  54                                  bool orientationCorrection,
  55                                  AtlasUploadObserver* atlasUploadObserver )
  56 {
  57   ImageDimensions dimensions = size;
  58   ImageDimensions zero;
  59   if( size == zero )
  60   {
  61     dimensions = Dali::GetClosestImageSize( url );
  62   }
  63
  64   // big image, atlasing is not applied
  65   if( static_cast<uint32_t>(dimensions.GetWidth()) * static_cast<uint32_t>(dimensions.GetHeight()) > MAX_ITEM_AREA
  66       || dimensions.GetWidth()>DEFAULT_ATLAS_SIZE
  67       || dimensions.GetHeight()>DEFAULT_ATLAS_SIZE)
  68   {
  69     return TextureSet();
  70   }
  71   size = dimensions;
  72
  73   unsigned int i = 0;
  74   for( AtlasContainer::iterator iter = mAtlasList.begin(); iter != mAtlasList.end(); ++iter)
  75   {
  76     if( (*iter).Upload( textureRect, url, size, fittingMode, orientationCorrection, atlasUploadObserver ) )
  77     {
  78       return mTextureSetList[i];
  79     }
  80     i++;
  81   }
  82
  83   CreateNewAtlas();
  84   mAtlasList.back().Upload( textureRect, url, size, fittingMode, orientationCorrection, atlasUploadObserver );
  85   return mTextureSetList.back();
  86 }
  87
  88 TextureSet ImageAtlasManager::Add( Vector4& textureRect,
  89                                    PixelData pixelData )
  90 {
  91
  92   // big buffer, atlasing is not applied
  93   if( static_cast<uint32_t>(pixelData.GetWidth()) * static_cast<uint32_t>(pixelData.GetHeight()) > MAX_ITEM_AREA
  94       || pixelData.GetWidth()>DEFAULT_ATLAS_SIZE
  95       || pixelData.GetHeight()>DEFAULT_ATLAS_SIZE )
  96   {
  97     return TextureSet();
  98   }
  99
 100   unsigned int i = 0;
 101   for( AtlasContainer::iterator iter = mAtlasList.begin(); iter != mAtlasList.end(); ++iter)
 102   {
 103     if( (*iter).Upload( textureRect, pixelData ) )
 104     {
 105       return mTextureSetList[i];
 106     }
 107     i++;
 108   }
 109
 110   CreateNewAtlas();
 111   mAtlasList.back().Upload( textureRect, pixelData );
 112   return mTextureSetList.back();
 113
 114 }
 115
 116 void ImageAtlasManager::Remove( TextureSet textureSet, const Vector4& textureRect )
 117 {
 118   unsigned int i = 0;
 119   for( TextureSetContainer::iterator iter = mTextureSetList.begin(); iter != mTextureSetList.end(); ++iter)
 120   {
 121     if( (*iter) == textureSet )
 122     {
 123       mAtlasList[i].Remove(textureRect);
 124       return;
 125     }
 126     i++;
 127   }
 128 }
 129
 130 void ImageAtlasManager::SetBrokenImage( const std::string& brokenImageUrl )
 131 {
 132   if( !brokenImageUrl.empty() )
 133   {
 134     mBrokenImageUrl = brokenImageUrl;
 135   }
 136 }
 137
 138 void ImageAtlasManager::CreateNewAtlas()
 139 {
 140   Toolkit::ImageAtlas newAtlas = Toolkit::ImageAtlas::New( DEFAULT_ATLAS_SIZE, DEFAULT_ATLAS_SIZE  );
 141   if( !mBrokenImageUrl.empty() )
 142   {
 143     newAtlas.SetBrokenImage( mBrokenImageUrl );
 144   }
 145   mAtlasList.push_back( newAtlas );
 146   TextureSet textureSet = TextureSet::New();
 147   textureSet.SetTexture( 0u, newAtlas.GetAtlas() );
 148   mTextureSetList.push_back( textureSet );
 149 }
 150
 151 } // namespace Internal
 152
 153 } // namespace Toolkit
 154
 155 } // namespace Dali