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 HEADER
  21 #include <dali/devel-api/common/hash.h>
  22 #include <dali/public-api/images/resource-image.h>
  23
  24 // INTERNAL HEADER
  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 void VisualFactoryCache::CacheWireframeRenderer( Renderer& renderer )
 154 {
 155   mWireframeRenderer = renderer;
 156 }
 157
 158 Renderer VisualFactoryCache::GetWireframeRenderer()
 159 {
 160   return mWireframeRenderer;
 161 }
 162
 163 Geometry VisualFactoryCache::CreateQuadGeometry()
 164 {
 165   const float halfWidth = 0.5f;
 166   const float halfHeight = 0.5f;
 167   struct QuadVertex { Vector2 position;};
 168   QuadVertex quadVertexData[4] =
 169   {
 170       { Vector2(-halfWidth, -halfHeight) },
 171       { Vector2(-halfWidth, halfHeight)  },
 172       { Vector2( halfWidth, -halfHeight) },
 173       { Vector2( halfWidth, halfHeight)  }
 174   };
 175
 176   Property::Map quadVertexFormat;
 177   quadVertexFormat["aPosition"] = Property::VECTOR2;
 178   PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
 179   quadVertices.SetData( quadVertexData, 4 );
 180
 181   // Create the geometry object
 182   Geometry geometry = Geometry::New();
 183   geometry.AddVertexBuffer( quadVertices );
 184   geometry.SetType( Geometry::TRIANGLE_STRIP );
 185
 186   return geometry;
 187 }
 188
 189 ImageAtlasManagerPtr VisualFactoryCache::GetAtlasManager()
 190 {
 191   if( !mAtlasManager )
 192   {
 193     mAtlasManager = new ImageAtlasManager();
 194     mAtlasManager->SetBrokenImage( BROKEN_VISUAL_IMAGE_URL );
 195   }
 196
 197   return mAtlasManager;
 198 }
 199
 200 SvgRasterizeThread* VisualFactoryCache::GetSVGRasterizationThread()
 201 {
 202   if( !mSvgRasterizeThread )
 203   {
 204     mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &VisualFactoryCache::ApplyRasterizedSVGToSampler ) ) );
 205     mSvgRasterizeThread->Start();
 206   }
 207   return mSvgRasterizeThread;
 208 }
 209
 210 void VisualFactoryCache::ApplyRasterizedSVGToSampler()
 211 {
 212   while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
 213   {
 214     task->GetSvgVisual()->ApplyRasterizedImage( task->GetPixelData() );
 215   }
 216 }
 217
 218 Geometry VisualFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
 219 {
 220   uint16_t gridWidth = gridSize.GetWidth();
 221   uint16_t gridHeight = gridSize.GetHeight();
 222
 223   // Create vertices
 224   Vector< Vector2 > vertices;
 225   vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
 226
 227   for( int y = 0; y < gridHeight + 1; ++y )
 228   {
 229     for( int x = 0; x < gridWidth + 1; ++x )
 230     {
 231       vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
 232     }
 233   }
 234
 235   // Create indices
 236   Vector< unsigned short > indices;
 237   indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
 238
 239   for( unsigned int row = 0u; row < gridHeight; ++row )
 240   {
 241     unsigned int rowStartIndex = row*(gridWidth+1u);
 242     unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
 243
 244     if( row != 0u ) // degenerate index on non-first row
 245     {
 246       indices.PushBack( rowStartIndex );
 247     }
 248
 249     for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
 250     {
 251       indices.PushBack( rowStartIndex + column);
 252       indices.PushBack( nextRowStartIndex + column);
 253     }
 254
 255     if( row != gridHeight-1u ) // degenerate index on non-last row
 256     {
 257       indices.PushBack( nextRowStartIndex + gridWidth );
 258     }
 259   }
 260
 261   Property::Map vertexFormat;
 262   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 263   PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
 264   if( vertices.Size() > 0 )
 265   {
 266     vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
 267   }
 268
 269   Property::Map indexFormat;
 270   indexFormat[ "indices" ] = Property::INTEGER;
 271   PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat );
 272
 273
 274   // Create the geometry object
 275   Geometry geometry = Geometry::New();
 276   geometry.AddVertexBuffer( vertexPropertyBuffer );
 277   if( indices.Size() > 0 )
 278   {
 279     geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
 280   }
 281
 282   geometry.SetType( Geometry::TRIANGLE_STRIP );
 283
 284   return geometry;
 285 }
 286
 287 Geometry VisualFactoryCache::CreateBatchQuadGeometry( Vector4 texCoords )
 288 {
 289   const float halfWidth = 0.5f;
 290   const float halfHeight = 0.5f;
 291   struct QuadVertex {
 292     QuadVertex( const Vector2& vertexPosition, const Vector2& vertexTexCoords )
 293       : position( vertexPosition ),
 294         texCoords( vertexTexCoords )
 295     {}
 296     Vector2 position;
 297     Vector2 texCoords;
 298   };
 299
 300   // special case, when texture takes whole space
 301   if( texCoords == Vector4::ZERO )
 302   {
 303     texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
 304   }
 305
 306   QuadVertex quadVertexData[6] =
 307   {
 308     QuadVertex( Vector2(-halfWidth,   -halfHeight ),   Vector2(texCoords.x, texCoords.y) ),
 309     QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
 310     QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
 311     QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
 312     QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
 313     QuadVertex( Vector2( halfWidth,    halfHeight ),   Vector2(texCoords.z, texCoords.w) ),
 314   };
 315
 316   Property::Map vertexFormat;
 317   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 318   vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
 319   PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
 320   vertexBuffer.SetData( quadVertexData, 6 );
 321
 322   // create geometry as normal, single quad
 323   Geometry geometry = Geometry::New();
 324   geometry.AddVertexBuffer( vertexBuffer );
 325   geometry.SetType( Geometry::TRIANGLES );
 326
 327   return geometry;
 328 }
 329
 330 Image VisualFactoryCache::GetBrokenVisualImage()
 331 {
 332   return ResourceImage::New( BROKEN_VISUAL_IMAGE_URL );
 333 }
 334
 335 } // namespace Internal
 336
 337 } // namespace Toolkit
 338
 339 } // namespace Dali
 340