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 Geometry RendererFactoryCache::CreateQuadGeometry()
 157 {
 158   const float halfWidth = 0.5f;
 159   const float halfHeight = 0.5f;
 160   struct QuadVertex { Vector2 position;};
 161   QuadVertex quadVertexData[4] =
 162   {
 163       { Vector2(-halfWidth, -halfHeight) },
 164       { Vector2( halfWidth, -halfHeight) },
 165       { Vector2(-halfWidth, halfHeight)  },
 166       { Vector2( halfWidth, halfHeight)  }
 167   };
 168
 169   Property::Map quadVertexFormat;
 170   quadVertexFormat["aPosition"] = Property::VECTOR2;
 171   PropertyBuffer quadVertices = PropertyBuffer::New( quadVertexFormat );
 172   quadVertices.SetData( quadVertexData, 4 );
 173
 174   // Create the geometry object
 175   Geometry geometry = Geometry::New();
 176   geometry.AddVertexBuffer( quadVertices );
 177   geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
 178
 179   return geometry;
 180 }
 181
 182 SvgRasterizeThread* RendererFactoryCache::GetSVGRasterizationThread()
 183 {
 184   if( !mSvgRasterizeThread )
 185   {
 186     mSvgRasterizeThread = new SvgRasterizeThread( new EventThreadCallback( MakeCallback( this, &RendererFactoryCache::ApplyRasterizedSVGToSampler ) ) );
 187     mSvgRasterizeThread->Start();
 188   }
 189   return mSvgRasterizeThread;
 190 }
 191
 192 void RendererFactoryCache::ApplyRasterizedSVGToSampler()
 193 {
 194   while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
 195   {
 196     task->GetSvgRenderer()->ApplyRasterizedImage( task->GetPixelData() );
 197   }
 198 }
 199
 200 } // namespace Internal
 201
 202 } // namespace Toolkit
 203
 204 } // namespace Dali
 205