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   Render::NewTexture* renderTexture(0);
 106   if( texture )
 107   {
 108     renderTexture = texture->GetRenderObject();
 109   }
 110
 111   SceneGraph::SetTextureMessage( mEventThreadServices, *mSceneObject, index, renderTexture );
 112 }
 113
 114 Image* TextureSet::GetImage( size_t index ) const
 115 {
 116   Image* result(0);
 117   if( index < mImages.size() )
 118   {
 119     result = mImages[index].Get();
 120   }
 121   else
 122   {
 123     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetImage");
 124   }
 125
 126   return result;
 127 }
 128
 129 NewTexture* TextureSet::GetTexture( size_t index ) const
 130 {
 131   NewTexture* result(0);
 132   if( index < mNewTextures.size() )
 133   {
 134     result = mNewTextures[index].Get();
 135   }
 136   else
 137   {
 138     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetTexture");
 139   }
 140
 141   return result;
 142 }
 143
 144 void TextureSet::SetSampler( size_t index, SamplerPtr sampler )
 145 {
 146   size_t samplerCount( mSamplers.size() );
 147   if( samplerCount < index + 1  )
 148   {
 149     mSamplers.resize( index + 1 );
 150     mNewTextures.resize( index + 1 );
 151     mImages.resize( index + 1 );
 152     for( size_t i(samplerCount); i<=index; ++i )
 153     {
 154       mImages[i] = NULL;
 155       mSamplers[i] = NULL;
 156       mNewTextures[i] = NULL;
 157     }
 158   }
 159
 160   mSamplers[index] = sampler;
 161
 162   Render::Sampler* renderSampler(0);
 163   if( sampler )
 164   {
 165     renderSampler = sampler->GetSamplerRenderObject();
 166   }
 167
 168   SceneGraph::SetSamplerMessage( mEventThreadServices, *mSceneObject, index, renderSampler );
 169 }
 170
 171 Sampler* TextureSet::GetSampler( size_t index ) const
 172 {
 173   Sampler* result(0);
 174   if( index < mSamplers.size() )
 175   {
 176     result = mSamplers[index].Get();
 177   }
 178   else
 179   {
 180     DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler");
 181   }
 182
 183   return result;
 184 }
 185
 186 size_t TextureSet::GetTextureCount() const
 187 {
 188   return mImages.size();
 189 }
 190
 191 const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
 192 {
 193   return mSceneObject;
 194 }
 195
 196 bool TextureSet::OnStage() const
 197 {
 198   return mOnStage;
 199 }
 200
 201 void TextureSet::Connect()
 202 {
 203   mOnStage = true;
 204
 205   for( size_t i(0); i<mImages.size(); ++i )
 206   {
 207     if( mImages[i] )
 208     {
 209       mImages[i]->Connect();
 210       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, mImages[i]->GetResourceId() );
 211     }
 212     else
 213     {
 214       SceneGraph::SetImageMessage( mEventThreadServices, *mSceneObject, i, Integration::InvalidResourceId );
 215     }
 216   }
 217 }
 218
 219 void TextureSet::Disconnect()
 220 {
 221   for( size_t i(0); i<mImages.size(); ++i )
 222   {
 223     if( mImages[i] )
 224     {
 225       mImages[i]->Disconnect();
 226     }
 227   }
 228
 229   mOnStage = false;
 230 }
 231
 232 TextureSet::TextureSet()
 233 :mEventThreadServices( *Stage::GetCurrent() ),
 234  mSceneObject( NULL ),
 235  mOnStage( false )
 236 {
 237 }
 238
 239 void TextureSet::Initialize()
 240 {
 241   SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 242
 243   mSceneObject = SceneGraph::TextureSet::New();
 244   AddTextureSetMessage( updateManager, *mSceneObject );
 245 }
 246
 247 TextureSet::~TextureSet()
 248 {
 249   if( EventThreadServices::IsCoreRunning() )
 250   {
 251     SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 252     RemoveTextureSetMessage( updateManager, *mSceneObject );
 253   }
 254 }
 255
 256 } // namespace Internal
 257 } // namespace Dali