dali/internal/event/rendering/texture-set-impl.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
  18 // CLASS HEADER
  19 #include <dali/internal/event/rendering/texture-set-impl.h> // Dali::Internal::TextureSet
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/object/type-registry.h>
  23 #include <dali/devel-api/rendering/texture-set.h> // Dali::Internal::Render::TextureSet
  24 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
  25 #include <dali/internal/update/manager/update-manager.h>
  26 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
  27
  28 namespace Dali
  29 {
  30 namespace Internal
  31 {
  32
  33 TextureSetPtr TextureSet::New()
  34 {
  35   TextureSetPtr textureSet( new TextureSet() );
  36   textureSet->Initialize();
  37   return textureSet;
  38 }
  39
  40 void TextureSet::SetImage( size_t index, ImagePtr image )
  41 {
  42   size_t textureCount( mTextures.size() );
  43   if( index < textureCount )
  44   {
  45     if( mTextures[index].image && mOnStage )
  46     {
  47       mTextures[index].image->Disconnect();
  48     }
  49   }
  50   else
  51   {
  52     mTextures.resize(index + 1);
  53     for( size_t i(textureCount); i<=index; ++i )
  54     {
  55       mTextures[i].image = NULL;
  56       mTextures[i].sampler = NULL;
  57     }
  58   }
  59   mTextures[index].image = image;
  60
  61
  62   if( image )
  63   {
  64     if( mOnStage )
  65     {
  66       image->Connect();
  67     }
  68     SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, index, image->GetResourceId() );
  69   }
  70   else
  71   {
  72     SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, index, Integration::InvalidResourceId );
  73   }
  74 }
  75
  76 Image* TextureSet::GetImage( size_t index ) const
  77 {
  78   Image* result(0);
  79   if( index < mTextures.size() )
  80   {
  81     result = mTextures[index].image.Get();
  82   }
  83   else
  84   {
  85     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetImage");
  86   }
  87
  88   return result;
  89 }
  90
  91 void TextureSet::SetSampler( size_t index, SamplerPtr sampler )
  92 {
  93   size_t textureCount( mTextures.size() );
  94   if( textureCount < index + 1  )
  95   {
  96     mTextures.resize(index + 1);
  97     for( size_t i(textureCount); i<=index; ++i )
  98     {
  99       mTextures[i].image = NULL;
 100       mTextures[i].sampler = NULL;
 101     }
 102   }
 103
 104   mTextures[index].sampler = sampler;
 105
 106   Render::Sampler* renderSampler(0);
 107   if( sampler )
 108   {
 109     renderSampler = sampler->GetSamplerRenderObject();
 110   }
 111
 112   SceneGraph::SetSamplerMessage( mEventThreadServices, *mSceneObject, index, renderSampler );
 113 }
 114
 115 Sampler* TextureSet::GetSampler( size_t index ) const
 116 {
 117   Sampler* result(0);
 118   if( index < mTextures.size() )
 119   {
 120     result = mTextures[index].sampler.Get();
 121   }
 122   else
 123   {
 124     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler");
 125   }
 126
 127   return result;
 128 }
 129
 130 size_t TextureSet::GetTextureCount() const
 131 {
 132   return mTextures.size();
 133 }
 134
 135 const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
 136 {
 137   return mSceneObject;
 138 }
 139
 140 bool TextureSet::OnStage() const
 141 {
 142   return mOnStage;
 143 }
 144
 145 void TextureSet::Connect()
 146 {
 147   mOnStage = true;
 148
 149   for( size_t i(0); i<mTextures.size(); ++i )
 150   {
 151     if( mTextures[i].image )
 152     {
 153       mTextures[i].image->Connect();
 154       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, mTextures[i].image->GetResourceId() );
 155     }
 156     else
 157     {
 158       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, Integration::InvalidResourceId );
 159     }
 160   }
 161 }
 162
 163 void TextureSet::Disconnect()
 164 {
 165   for( size_t i(0); i<mTextures.size(); ++i )
 166   {
 167     if( mTextures[i].image )
 168     {
 169       mTextures[i].image->Disconnect();
 170     }
 171   }
 172
 173   mOnStage = false;
 174 }
 175
 176 TextureSet::TextureSet()
 177 :mEventThreadServices( *Stage::GetCurrent() ),
 178  mSceneObject( NULL ),
 179  mTextures(),
 180  mOnStage( false )
 181 {
 182 }
 183
 184 void TextureSet::Initialize()
 185 {
 186   SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 187
 188   mSceneObject = SceneGraph::TextureSet::New();
 189   AddTextureSetMessage( updateManager, *mSceneObject );
 190 }
 191
 192 TextureSet::~TextureSet()
 193 {
 194   if( EventThreadServices::IsCoreRunning() )
 195   {
 196     SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 197     RemoveTextureSetMessage( updateManager, *mSceneObject );
 198   }
 199 }
 200
 201 } // namespace Internal
 202 } // namespace Dali