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
  26 namespace Dali
  27 {
  28
  29 namespace Toolkit
  30 {
  31
  32 namespace Internal
  33 {
  34
  35 RendererFactoryCache::RendererFactoryCache()
  36 {
  37 }
  38
  39 RendererFactoryCache::~RendererFactoryCache()
  40 {
  41 }
  42
  43 Geometry RendererFactoryCache::GetGeometry( GeometryType type )
  44 {
  45   return mGeometry[type];
  46 }
  47
  48 void RendererFactoryCache::SaveGeometry( GeometryType type, Geometry geometry )
  49 {
  50   mGeometry[type] = geometry;
  51 }
  52
  53 Shader RendererFactoryCache::GetShader( ShaderType type )
  54 {
  55   return mShader[type];
  56 }
  57
  58 void RendererFactoryCache::SaveShader( ShaderType type, Shader shader )
  59 {
  60   mShader[type] = shader;
  61 }
  62
  63 int RendererFactoryCache::FindRenderer( const std::string& key ) const
  64 {
  65   int hash = Dali::CalculateHash( key );
  66
  67   HashVector::Iterator startIt = mRendererHashes.Begin();
  68   HashVector::Iterator it;
  69
  70   for(;;)
  71   {
  72     it = std::find( startIt, mRendererHashes.End(), hash );
  73     if( it != mRendererHashes.End() )
  74     {
  75       int index = it - mRendererHashes.Begin();
  76       const CachedRenderer* cachedRenderer = mRenderers[ index ];
  77
  78       if( cachedRenderer && cachedRenderer->mKey == key )
  79       {
  80         return index;
  81       }
  82     }
  83     else
  84     {
  85       break;
  86     }
  87     startIt = it + 1;
  88   }
  89
  90   return -1;
  91 }
  92
  93 Renderer RendererFactoryCache::GetRenderer( const std::string& key ) const
  94 {
  95   int index = FindRenderer( key );
  96   if( index != -1 )
  97   {
  98     return mRenderers[ index ]->mRenderer.GetHandle();
  99   }
 100   else
 101   {
 102     return Renderer();
 103   }
 104 }
 105
 106 void RendererFactoryCache::SaveRenderer( const std::string& key, Renderer& renderer )
 107 {
 108   int hash = Dali::CalculateHash( key );
 109   const CachedRenderer* cachedRenderer = new CachedRenderer( key, renderer );
 110
 111   CachedRenderers::Iterator it = std::find( mRenderers.Begin(), mRenderers.End(), static_cast< CachedRenderer* >( NULL ) );
 112   if( it != mRenderers.End() )
 113   {
 114     *it = cachedRenderer;
 115     int index = it - mRenderers.Begin();
 116     mRendererHashes[ index ] = hash;
 117   }
 118   else
 119   {
 120     mRendererHashes.PushBack( hash );
 121     mRenderers.PushBack( cachedRenderer );
 122   }
 123 }
 124
 125 bool RendererFactoryCache::CleanRendererCache( const std::string& key )
 126 {
 127   int index = FindRenderer( key );
 128   if( index != -1 )
 129   {
 130     const CachedRenderer*& cachedRenderer = mRenderers[ index ];
 131     if( !cachedRenderer->mRenderer.GetHandle() )
 132     {
 133       mRendererHashes[ index ] = Dali::INITIAL_HASH_VALUE;
 134
 135       delete cachedRenderer;
 136       cachedRenderer = NULL;
 137       return true;
 138     }
 139   }
 140   return false;
 141 }
 142
 143 void RendererFactoryCache::CacheDebugRenderer( Renderer& renderer )
 144 {
 145   mDebugRenderer = renderer;
 146 }
 147
 148 Renderer RendererFactoryCache::GetDebugRenderer()
 149 {
 150   return mDebugRenderer;
 151 }
 152
 153 Geometry RendererFactoryCache::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.SetGeometryType( Geometry::TRIANGLE_STRIP );
 175
 176   return geometry;
 177 }
 178
 179 } // namespace Internal
 180
 181 } // namespace Toolkit
 182
 183 } // namespace Dali
 184