dali-toolkit/internal/visuals/visual-factory-cache.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 // CLASS HEADER
  18 #include "visual-factory-cache.h"
  19
  20 // EXTERNAL INCLUDES
  21 #include <dali/devel-api/common/hash.h>
  22 #include <dali/public-api/images/resource-image.h>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali-toolkit/internal/visuals/color/color-visual.h>
  26 #include <dali-toolkit/internal/visuals/svg/svg-visual.h>
  27 #include <dali-toolkit/internal/visuals/image-atlas-manager.h>
  28
  29 namespace
  30 {
  31 const char * const BROKEN_VISUAL_IMAGE_URL( DALI_IMAGE_DIR "broken.png");
  32 }
  33
  34 namespace Dali
  35 {
  36
  37 namespace Toolkit
  38 {
  39
  40 namespace Internal
  41 {
  42
  43 VisualFactoryCache::VisualFactoryCache()
  44 : mSvgRasterizeThread( NULL )
  45 {
  46 }
  47
  48 VisualFactoryCache::~VisualFactoryCache()
  49 {
  50   SvgRasterizeThread::TerminateThread( mSvgRasterizeThread );
  51 }
  52
  53 Geometry VisualFactoryCache::GetGeometry( GeometryType type )
  54 {
  55   return mGeometry[type];
  56 }
  57
  58 void VisualFactoryCache::SaveGeometry( GeometryType type, Geometry geometry )
  59 {
  60   mGeometry[type] = geometry;
  61 }
  62
  63 Shader VisualFactoryCache::GetShader( ShaderType type )
  64 {
  65   return mShader[type];
  66 }
  67
  68 void VisualFactoryCache::SaveShader( ShaderType type, Shader shader )
  69 {
  70   mShader[type] = shader;
  71 }
  72
  73 int VisualFactoryCache::FindRenderer( const std::string& key ) const
  74 {
  75   int hash = Dali::CalculateHash( key );
  76
  77   HashVector::Iterator startIt = mRendererHashes.Begin();
  78   HashVector::Iterator it;
  79
  80   for(;;)
  81   {
  82     it = std::find( startIt, mRendererHashes.End(), hash );
  83     if( it != mRendererHashes.End() )
  84     {
  85       int index = it - mRendererHashes.Begin();
  86       const CachedRenderer* cachedRenderer = mRenderers[ index ];
  87
  88       if( cachedRenderer && cachedRenderer->mKey == key )
  89       {
  90         return index;
  91       }
  92     }
  93     else
  94     {
  95       break;
  96     }
  97     startIt = it + 1;
  98   }
  99
 100   return -1;
 101 }
 102
 103 Renderer VisualFactoryCache::GetRenderer( const std::string& key ) const
 104 {
 105   int index = FindRenderer( key );
 106   if( index != -1 )
 107   {
 108     return mRenderers[ index ]->mRenderer.GetHandle();
 109   }
 110   else
 111   {
 112     return Renderer();
 113   }
 114 }
 115
 116 void VisualFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
 117 {
 118   int hash = Dali::CalculateHash( key );
 119   const CachedRenderer* cachedRenderer = new CachedRenderer( key, renderer );
 120
 121   CachedRenderers::Iterator it = std::find( mRenderers.Begin(), mRenderers.End(), static_cast< CachedRenderer* >( NULL ) );
 122   if( it != mRenderers.End() )
 123   {
 124     *it = cachedRenderer;
 125     int index = it - mRenderers.Begin();
 126     mRendererHashes[ index ] = hash;
 127   }
 128   else
 129   {
 130     mRendererHashes.PushBack( hash );
 131     mRenderers.PushBack( cachedRenderer );
 132   }
 133 }
 134
 135 bool VisualFactoryCache::CleanRendererCache( const std::string& key )
 136 {
 137   int index = FindRenderer( key );
 138   if( index != -1 )
 139   {
 140     const CachedRenderer*& cachedRenderer = mRenderers[ index ];
 141     if( !cachedRenderer->mRenderer.GetHandle() )
 142     {
 143       mRendererHashes[ index ] = Dali::INITIAL_HASH_VALUE;
 144
 145       delete cachedRenderer;
 146       cachedRenderer = NULL;
 147       return true;
 148     }
 149   }
 150   return false;
 151 }
 152
 153 Geometry VisualFactoryCache::CreateQuadGeometry()
 154 {
 155   const float halfWidth = 0.5f;
 156   const float halfHeight = 0.5f;
 157   struct QuadVertex { Vector2 position;};
 158   QuadVertex quadVertexData[4] =
 159   {
 160       { Vector2(-halfWidth, -halfHeight) },
 161       { Vector2(-halfWidth, halfHeight)  },
 162       { Vector2( halfWidth, -halfHeight) },
 163       { Vector2( halfWidth, halfHeight)  }
 164   };
 165
 166   Property::Map quadVertexFormat;
 167   quadVertexFormat["aPosition"] = Property::VECTOR2;
 168   PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
 169   quadVertices.SetData( quadVertexData, 4 );
 170
 171   // Create the geometry object
 172   Geometry geometry = Geometry::New();
 173   geometry.AddVertexBuffer( quadVertices );
 174   geometry.SetType( Geometry::TRIANGLE_STRIP );
 175
 176   return geometry;
 177 }
 178
 179 ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
 180 {
 181   if( !mAtlasManager )
 182   {
 183     mAtlasManager = new ImageAtlasManager();
 184     mAtlasManager->SetBrokenImage( BROKEN_VISUAL_IMAGE_URL );
 185   }
 186
 187   return mAtlasManager;
 188 }
 189
 190 NPatchLoader& VisualFactoryCache::GetNPatchLoader()
 191 {
 192   return mNPatchLoader;
 193 }
 194
 195 SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
 196 {
 197   if( !mSvgRasterizeThread )
 198   {
 199     mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &VisualFactoryCache::ApplyRasterizedSVGToSampler ) ) );
 200     mSvgRasterizeThread->Start();
 201   }
 202   return mSvgRasterizeThread;
 203 }
 204
 205 void VisualFactoryCache::ApplyRasterizedSVGToSampler()
 206 {
 207   while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
 208   {
 209     task->GetSvgVisual()->ApplyRasterizedImage( task->GetPixelData() );
 210   }
 211 }
 212
 213 Geometry VisualFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
 214 {
 215   uint16_t gridWidth = gridSize.GetWidth();
 216   uint16_t gridHeight = gridSize.GetHeight();
 217
 218   // Create vertices
 219   Vector< Vector2 > vertices;
 220   vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
 221
 222   for( int y = 0; y < gridHeight + 1; ++y )
 223   {
 224     for( int x = 0; x < gridWidth + 1; ++x )
 225     {
 226       vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
 227     }
 228   }
 229
 230   // Create indices
 231   Vector< unsigned short > indices;
 232   indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
 233
 234   for( unsigned int row = 0u; row < gridHeight; ++row )
 235   {
 236     unsigned int rowStartIndex = row*(gridWidth+1u);
 237     unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
 238
 239     if( row != 0u ) // degenerate index on non-first row
 240     {
 241       indices.PushBack( rowStartIndex );
 242     }
 243
 244     for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
 245     {
 246       indices.PushBack( rowStartIndex + column);
 247       indices.PushBack( nextRowStartIndex + column);
 248     }
 249
 250     if( row != gridHeight-1u ) // degenerate index on non-last row
 251     {
 252       indices.PushBack( nextRowStartIndex + gridWidth );
 253     }
 254   }
 255
 256   Property::Map vertexFormat;
 257   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 258   PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
 259   if( vertices.Size() > 0 )
 260   {
 261     vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
 262   }
 263
 264   Property::Map indexFormat;
 265   indexFormat[ "indices" ] = Property::INTEGER;
 266   PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat );
 267
 268
 269   // Create the geometry object
 270   Geometry geometry = Geometry::New();
 271   geometry.AddVertexBuffer( vertexPropertyBuffer );
 272   if( indices.Size() > 0 )
 273   {
 274     geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
 275   }
 276
 277   geometry.SetType( Geometry::TRIANGLE_STRIP );
 278
 279   return geometry;
 280 }
 281
 282 Geometry VisualFactoryCache::CreateBatchQuadGeometry( Vector4 texCoords )
 283 {
 284   const float halfWidth = 0.5f;
 285   const float halfHeight = 0.5f;
 286   struct QuadVertex {
 287     QuadVertex( const Vector2& vertexPosition, const Vector2& vertexTexCoords )
 288       : position( vertexPosition ),
 289         texCoords( vertexTexCoords )
 290     {}
 291     Vector2 position;
 292     Vector2 texCoords;
 293   };
 294
 295   // special case, when texture takes whole space
 296   if( texCoords == Vector4::ZERO )
 297   {
 298     texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
 299   }
 300
 301   QuadVertex quadVertexData[6] =
 302   {
 303     QuadVertex( Vector2(-halfWidth,   -halfHeight ),   Vector2(texCoords.x, texCoords.y) ),
 304     QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
 305     QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
 306     QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
 307     QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
 308     QuadVertex( Vector2( halfWidth,    halfHeight ),   Vector2(texCoords.z, texCoords.w) ),
 309   };
 310
 311   Property::Map vertexFormat;
 312   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 313   vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
 314   PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
 315   vertexBuffer.SetData( quadVertexData, 6 );
 316
 317   // create geometry as normal, single quad
 318   Geometry geometry = Geometry::New();
 319   geometry.AddVertexBuffer( vertexBuffer );
 320   geometry.SetType( Geometry::TRIANGLES );
 321
 322   return geometry;
 323 }
 324
 325 Image VisualFactoryCache::GetBrokenVisualImage()
 326 {
 327   return ResourceImage::New( BROKEN_VISUAL_IMAGE_URL );
 328 }
 329
 330 } // namespace Internal
 331
 332 } // namespace Toolkit
 333
 334 } // namespace Dali
 335