dali-toolkit/internal/controls/renderers/renderer-factory-cache.cpp

   1  /*
   2  * Copyright (c) 2015 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 "renderer-factory-cache.h"
  19
  20 // EXTERNAL HEADER
  21 #include <dali/devel-api/common/hash.h>
  22
  23 // INTERNAL HEADER
  24 #include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
  25 #include <dali-toolkit/internal/controls/renderers/svg/svg-renderer.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Toolkit
  31 {
  32
  33 namespace Internal
  34 {
  35
  36 RendererFactoryCache::RendererFactoryCache()
  37 : mSvgRasterizeThread( NULL )
  38 {
  39 }
  40
  41 RendererFactoryCache::~RendererFactoryCache()
  42 {
  43   SvgRasterizeThread::TerminateThread( mSvgRasterizeThread );
  44 }
  45
  46 Geometry RendererFactoryCache::GetGeometry( GeometryType type )
  47 {
  48   return mGeometry[type];
  49 }
  50
  51 void RendererFactoryCache::SaveGeometry( GeometryType type, Geometry geometry )
  52 {
  53   mGeometry[type] = geometry;
  54 }
  55
  56 Shader RendererFactoryCache::GetShader( ShaderType type )
  57 {
  58   return mShader[type];
  59 }
  60
  61 void RendererFactoryCache::SaveShader( ShaderType type, Shader shader )
  62 {
  63   mShader[type] = shader;
  64 }
  65
  66 int RendererFactoryCache::FindRenderer( const std::string& key ) const
  67 {
  68   int hash = Dali::CalculateHash( key );
  69
  70   HashVector::Iterator startIt = mRendererHashes.Begin();
  71   HashVector::Iterator it;
  72
  73   for(;;)
  74   {
  75     it = std::find( startIt, mRendererHashes.End(), hash );
  76     if( it != mRendererHashes.End() )
  77     {
  78       int index = it - mRendererHashes.Begin();
  79       const CachedRenderer* cachedRenderer = mRenderers[ index ];
  80
  81       if( cachedRenderer && cachedRenderer->mKey == key )
  82       {
  83         return index;
  84       }
  85     }
  86     else
  87     {
  88       break;
  89     }
  90     startIt = it + 1;
  91   }
  92
  93   return -1;
  94 }
  95
  96 Renderer RendererFactoryCache::GetRenderer( const std::string& key ) const
  97 {
  98   int index = FindRenderer( key );
  99   if( index != -1 )
 100   {
 101     return mRenderers[ index ]->mRenderer.GetHandle();
 102   }
 103   else
 104   {
 105     return Renderer();
 106   }
 107 }
 108
 109 void RendererFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
 110 {
 111   int hash = Dali::CalculateHash( key );
 112   const CachedRenderer* cachedRenderer = new CachedRenderer( key, renderer );
 113
 114   CachedRenderers::Iterator it = std::find( mRenderers.Begin(), mRenderers.End(), static_cast< CachedRenderer* >( NULL ) );
 115   if( it != mRenderers.End() )
 116   {
 117     *it = cachedRenderer;
 118     int index = it - mRenderers.Begin();
 119     mRendererHashes[ index ] = hash;
 120   }
 121   else
 122   {
 123     mRendererHashes.PushBack( hash );
 124     mRenderers.PushBack( cachedRenderer );
 125   }
 126 }
 127
 128 bool RendererFactoryCache::CleanRendererCache( const std::string& key )
 129 {
 130   int index = FindRenderer( key );
 131   if( index != -1 )
 132   {
 133     const CachedRenderer*& cachedRenderer = mRenderers[ index ];
 134     if( !cachedRenderer->mRenderer.GetHandle() )
 135     {
 136       mRendererHashes[ index ] = Dali::INITIAL_HASH_VALUE;
 137
 138       delete cachedRenderer;
 139       cachedRenderer = NULL;
 140       return true;
 141     }
 142   }
 143   return false;
 144 }
 145
 146 void RendererFactoryCache::CacheDebugRenderer( Renderer& renderer )
 147 {
 148   mDebugRenderer = renderer;
 149 }
 150
 151 Renderer RendererFactoryCache::GetDebugRenderer()
 152 {
 153   return mDebugRenderer;
 154 }
 155
 156 SvgRasterizeThread* RendererFactoryCache::GetSVGRasterizationThread()
 157 {
 158   if( !mSvgRasterizeThread )
 159   {
 160     mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &RendererFactoryCache::ApplyRasterizedSVGToSampler ) ) );
 161     mSvgRasterizeThread->Start();
 162   }
 163   return mSvgRasterizeThread;
 164 }
 165
 166 void RendererFactoryCache::ApplyRasterizedSVGToSampler()
 167 {
 168   while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
 169   {
 170     task->GetSvgRenderer()->ApplyRasterizedImage( task->GetPixelData() );
 171   }
 172 }
 173
 174 Geometry RendererFactoryCache::CreateGridGeometry( Uint16Pair gridSize )
 175 {
 176   uint16_t gridWidth = gridSize.GetWidth();
 177   uint16_t gridHeight = gridSize.GetHeight();
 178
 179   // Create vertices
 180   Vector< Vector2 > vertices;
 181   vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) );
 182
 183   for( int y = 0; y < gridHeight + 1; ++y )
 184   {
 185     for( int x = 0; x < gridWidth + 1; ++x )
 186     {
 187       vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight  - 0.5f) );
 188     }
 189   }
 190
 191   // Create indices
 192   Vector< unsigned short > indices;
 193   indices.Reserve( (gridWidth+2)*gridHeight*2 - 2);
 194
 195   for( unsigned int row = 0u; row < gridHeight; ++row )
 196   {
 197     unsigned int rowStartIndex = row*(gridWidth+1u);
 198     unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u;
 199
 200     if( row != 0u ) // degenerate index on non-first row
 201     {
 202       indices.PushBack( rowStartIndex );
 203     }
 204
 205     for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip
 206     {
 207       indices.PushBack( rowStartIndex + column);
 208       indices.PushBack( nextRowStartIndex + column);
 209     }
 210
 211     if( row != gridHeight-1u ) // degenerate index on non-last row
 212     {
 213       indices.PushBack( nextRowStartIndex + gridWidth );
 214     }
 215   }
 216
 217   Property::Map vertexFormat;
 218   vertexFormat[ "aPosition" ] = Property::VECTOR2;
 219   PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat );
 220   if( vertices.Size() > 0 )
 221   {
 222     vertexPropertyBuffer.SetData( &vertices[ 0 ], vertices.Size() );
 223   }
 224
 225   Property::Map indexFormat;
 226   indexFormat[ "indices" ] = Property::INTEGER;
 227   PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat );
 228
 229
 230   // Create the geometry object
 231   Geometry geometry = Geometry::New();
 232   geometry.AddVertexBuffer( vertexPropertyBuffer );
 233   if( indices.Size() > 0 )
 234   {
 235     geometry.SetIndexBuffer( &indices[ 0 ], indices.Size() );
 236   }
 237
 238   geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
 239
 240   return geometry;
 241 }
 242
 243 } // namespace Internal
 244
 245 } // namespace Toolkit
 246
 247 } // namespace Dali
 248