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   if( !mNewTextures.empty() )
  43   {
  44     DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same TextureSet");
  45     return;
  46   }
  47
  48   size_t textureCount( mImages.size() );
  49   if( index < textureCount )
  50   {
  51     if( mImages[index] && mOnStage )
  52     {
  53       mImages[index]->Disconnect();
  54     }
  55   }
  56   else
  57   {
  58     mImages.resize(index + 1);
  59     mSamplers.resize(index + 1);
  60     for( size_t i(textureCount); i<=index; ++i )
  61     {
  62       mImages[i] = NULL;
  63       mSamplers[i] = NULL;
  64     }
  65   }
  66   mImages[index] = image;
  67
  68
  69   if( image )
  70   {
  71     if( mOnStage )
  72     {
  73       image->Connect();
  74     }
  75     SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, index, image->GetResourceId() );
  76   }
  77   else
  78   {
  79     SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, index, Integration::InvalidResourceId );
  80   }
  81 }
  82
  83 void TextureSet::SetTexture( size_t index, NewTexturePtr texture )
  84 {
  85   if( !mImages.empty() )
  86   {
  87     DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same texture set");
  88     return;
  89   }
  90
  91   size_t textureCount( mNewTextures.size() );
  92   if( index >= textureCount )
  93   {
  94     mNewTextures.resize(index + 1);
  95     mSamplers.resize(index + 1);
  96     for( size_t i(textureCount); i<=index; ++i )
  97     {
  98       mNewTextures[i] = NULL;
  99       mSamplers[i] = NULL;
 100     }
 101   }
 102
 103   mNewTextures[index]= texture;
 104
 105
 106   SceneGraph::SetTextureMessage( mEventThreadServices, *mSceneObject, index, texture->GetRenderObject() );
 107
 108 }
 109
 110 Image* TextureSet::GetImage( size_t index ) const
 111 {
 112   Image* result(0);
 113   if( index < mImages.size() )
 114   {
 115     result = mImages[index].Get();
 116   }
 117   else
 118   {
 119     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetImage");
 120   }
 121
 122   return result;
 123 }
 124
 125 NewTexture* TextureSet::GetTexture( size_t index ) const
 126 {
 127   NewTexture* result(0);
 128   if( index < mNewTextures.size() )
 129   {
 130     result = mNewTextures[index].Get();
 131   }
 132   else
 133   {
 134     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetTexture");
 135   }
 136
 137   return result;
 138 }
 139
 140 void TextureSet::SetSampler( size_t index, SamplerPtr sampler )
 141 {
 142   size_t samplerCount( mSamplers.size() );
 143   if( samplerCount < index + 1  )
 144   {
 145     mSamplers.resize( index + 1 );
 146     mNewTextures.resize( index + 1 );
 147     mImages.resize( index + 1 );
 148     for( size_t i(samplerCount); i<=index; ++i )
 149     {
 150       mImages[i] = NULL;
 151       mSamplers[i] = NULL;
 152       mNewTextures[i] = NULL;
 153     }
 154   }
 155
 156   mSamplers[index] = sampler;
 157
 158   Render::Sampler* renderSampler(0);
 159   if( sampler )
 160   {
 161     renderSampler = sampler->GetSamplerRenderObject();
 162   }
 163
 164   SceneGraph::SetSamplerMessage( mEventThreadServices, *mSceneObject, index, renderSampler );
 165 }
 166
 167 Sampler* TextureSet::GetSampler( size_t index ) const
 168 {
 169   Sampler* result(0);
 170   if( index < mSamplers.size() )
 171   {
 172     result = mSamplers[index].Get();
 173   }
 174   else
 175   {
 176     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler");
 177   }
 178
 179   return result;
 180 }
 181
 182 size_t TextureSet::GetTextureCount() const
 183 {
 184   return mImages.size();
 185 }
 186
 187 const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
 188 {
 189   return mSceneObject;
 190 }
 191
 192 bool TextureSet::OnStage() const
 193 {
 194   return mOnStage;
 195 }
 196
 197 void TextureSet::Connect()
 198 {
 199   mOnStage = true;
 200
 201   for( size_t i(0); i<mImages.size(); ++i )
 202   {
 203     if( mImages[i] )
 204     {
 205       mImages[i]->Connect();
 206       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, mImages[i]->GetResourceId() );
 207     }
 208     else
 209     {
 210       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, Integration::InvalidResourceId );
 211     }
 212   }
 213 }
 214
 215 void TextureSet::Disconnect()
 216 {
 217   for( size_t i(0); i<mImages.size(); ++i )
 218   {
 219     if( mImages[i] )
 220     {
 221       mImages[i]->Disconnect();
 222     }
 223   }
 224
 225   mOnStage = false;
 226 }
 227
 228 TextureSet::TextureSet()
 229 :mEventThreadServices( *Stage::GetCurrent() ),
 230  mSceneObject( NULL ),
 231  mOnStage( false )
 232 {
 233 }
 234
 235 void TextureSet::Initialize()
 236 {
 237   SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 238
 239   mSceneObject = SceneGraph::TextureSet::New();
 240   AddTextureSetMessage( updateManager, *mSceneObject );
 241 }
 242
 243 TextureSet::~TextureSet()
 244 {
 245   if( EventThreadServices::IsCoreRunning() )
 246   {
 247     SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 248     RemoveTextureSetMessage( updateManager, *mSceneObject );
 249   }
 250 }
 251
 252 } // namespace Internal
 253 } // namespace Dali