dali/internal/event/rendering/sampler-impl.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
  18 // CLASS HEADER
  19 #include <dali/internal/event/rendering/sampler-impl.h> // Dali::Internal::Sampler
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/object/type-registry.h>
  23 #include <dali/devel-api/rendering/sampler.h> // Dali::Internal::Sampler
  24 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
  25 #include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
  26 #include <dali/internal/update/rendering/scene-graph-sampler.h> // Dali::Internal::SceneGraph::Sampler
  27 #include <dali/internal/update/manager/update-manager.h>
  28
  29 namespace Dali
  30 {
  31 namespace Internal
  32 {
  33
  34 namespace
  35 {
  36
  37 /**
  38  *            |name                    |type     |writable|animatable|constraint-input|enum for index-checking|
  39  */
  40 DALI_PROPERTY_TABLE_BEGIN
  41 DALI_PROPERTY( "minification-filter",   INTEGER,   true, false,  true, Dali::Sampler::Property::MINIFICATION_FILTER )
  42 DALI_PROPERTY( "magnification-filter",  INTEGER,   true, false,  true, Dali::Sampler::Property::MAGNIGICATION_FILTER )
  43 DALI_PROPERTY( "u-wrap",                INTEGER,   true, false,  true, Dali::Sampler::Property::U_WRAP )
  44 DALI_PROPERTY( "v-wrap",                INTEGER,   true, false,  true, Dali::Sampler::Property::V_WRAP )
  45 DALI_PROPERTY( "affects-transparency",  BOOLEAN,  true, false,  true, Dali::Sampler::Property::AFFECTS_TRANSPARENCY )
  46 DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
  47
  48 const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SAMPLER_IMPL = { DEFAULT_PROPERTY_DETAILS };
  49
  50 BaseHandle Create()
  51 {
  52   return Dali::BaseHandle();
  53 }
  54
  55 TypeRegistration mType( typeid( Dali::Sampler ), typeid( Dali::Handle ), Create );
  56
  57 } // unnamed namespace
  58
  59 SamplerPtr Sampler::New( const std::string& textureUnitUniformName )
  60 {
  61   SamplerPtr sampler( new Sampler() );
  62   sampler->Initialize( textureUnitUniformName );
  63   return sampler;
  64 }
  65
  66 void Sampler::SetTextureUnitUniformName( const std::string& name )
  67 {
  68   SetTextureUnitUniformNameMessage( GetEventThreadServices(), *mSceneObject, name);
  69 }
  70
  71 const std::string& Sampler::GetTextureUnitUniformName() const
  72 {
  73   return mSceneObject->GetTextureUnitUniformName();
  74 }
  75
  76 void Sampler::SetImage( ImagePtr& image )
  77 {
  78   // Keep a reference to the image object
  79   mImageConnector.Set( image, OnStage() );
  80
  81   // sceneObject is being used in a separate thread; queue a message to set
  82   if( mOnStage )
  83   {
  84     unsigned int resourceId = image->GetResourceId();
  85     if( resourceId != 0 )
  86     {
  87       SetTextureMessage( GetEventThreadServices(), *mSceneObject, resourceId );
  88     }
  89   }
  90 }
  91
  92 ImagePtr Sampler::GetImage() const
  93 {
  94   return mImageConnector.Get();
  95 }
  96
  97 void Sampler::SetFilterMode( Dali::Sampler::FilterMode minFilter, Dali::Sampler::FilterMode magFilter )
  98 {
  99   if( NULL != mSceneObject )
 100   {
 101     SetFilterModeMessage( GetEventThreadServices(), *mSceneObject, minFilter, magFilter );
 102   }
 103 }
 104
 105 void Sampler::SetWrapMode( Dali::Sampler::WrapMode uWrap, Dali::Sampler::WrapMode vWrap )
 106 {
 107   if( NULL != mSceneObject )
 108   {
 109     SetWrapModeMessage( GetEventThreadServices(), *mSceneObject, uWrap, vWrap );
 110   }
 111 }
 112
 113 void Sampler::SetAffectsTransparency( bool affectsTransparency )
 114 {
 115   if( NULL != mSceneObject )
 116   {
 117     SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mAffectsTransparency, &SceneGraph::DoubleBufferedProperty<bool>::Set, affectsTransparency );
 118   }
 119 }
 120
 121 const SceneGraph::Sampler* Sampler::GetSamplerSceneObject() const
 122 {
 123   return mSceneObject;
 124 }
 125
 126 SceneGraph::Sampler* Sampler::GetSamplerSceneObject()
 127 {
 128   return mSceneObject;
 129 }
 130
 131 unsigned int Sampler::GetDefaultPropertyCount() const
 132 {
 133   return SAMPLER_IMPL.GetDefaultPropertyCount();
 134 }
 135
 136 void Sampler::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
 137 {
 138   SAMPLER_IMPL.GetDefaultPropertyIndices( indices );
 139 }
 140
 141 const char* Sampler::GetDefaultPropertyName(Property::Index index) const
 142 {
 143   return SAMPLER_IMPL.GetDefaultPropertyName( index );
 144 }
 145
 146 Property::Index Sampler::GetDefaultPropertyIndex( const std::string& name ) const
 147 {
 148   return SAMPLER_IMPL.GetDefaultPropertyIndex( name );
 149 }
 150
 151 bool Sampler::IsDefaultPropertyWritable( Property::Index index ) const
 152 {
 153   return SAMPLER_IMPL.IsDefaultPropertyWritable( index );
 154 }
 155
 156 bool Sampler::IsDefaultPropertyAnimatable( Property::Index index ) const
 157 {
 158   return SAMPLER_IMPL.IsDefaultPropertyAnimatable( index );
 159 }
 160
 161 bool Sampler::IsDefaultPropertyAConstraintInput( Property::Index index ) const
 162 {
 163   return SAMPLER_IMPL.IsDefaultPropertyAConstraintInput( index );
 164 }
 165
 166 Property::Type Sampler::GetDefaultPropertyType( Property::Index index ) const
 167 {
 168   return SAMPLER_IMPL.GetDefaultPropertyType( index );
 169 }
 170
 171 void Sampler::SetDefaultProperty( Property::Index index,
 172                                   const Property::Value& propertyValue )
 173 {
 174   switch( index )
 175   {
 176     case Dali::Sampler::Property::MINIFICATION_FILTER:
 177     {
 178       SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mMinFilter, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
 179       break;
 180     }
 181     case Dali::Sampler::Property::MAGNIGICATION_FILTER:
 182     {
 183       SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mMagFilter, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
 184       break;
 185     }
 186     case Dali::Sampler::Property::U_WRAP:
 187     {
 188       SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mUWrapMode, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
 189       break;
 190     }
 191     case Dali::Sampler::Property::V_WRAP:
 192     {
 193       SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mVWrapMode, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
 194       break;
 195     }
 196     case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
 197     {
 198       SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mAffectsTransparency, &SceneGraph::DoubleBufferedProperty<bool>::Set, propertyValue.Get<bool>() );
 199       break;
 200     }
 201   }
 202 }
 203
 204 void Sampler::SetSceneGraphProperty( Property::Index index,
 205                                      const PropertyMetadata& entry,
 206                                      const Property::Value& value )
 207 {
 208   SAMPLER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
 209   OnPropertySet(index, value);
 210 }
 211
 212 Property::Value Sampler::GetDefaultProperty( Property::Index index ) const
 213 {
 214   BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
 215   Property::Value value;
 216
 217   switch( index )
 218   {
 219     case Dali::Sampler::Property::MINIFICATION_FILTER:
 220     {
 221       value = mSceneObject->mMinFilter[bufferIndex];
 222       break;
 223     }
 224     case Dali::Sampler::Property::MAGNIGICATION_FILTER:
 225     {
 226       value = mSceneObject->mMagFilter[bufferIndex];
 227       break;
 228     }
 229     case Dali::Sampler::Property::U_WRAP:
 230     {
 231       value = mSceneObject->mUWrapMode[bufferIndex];
 232       break;
 233     }
 234     case Dali::Sampler::Property::V_WRAP:
 235     {
 236       value = mSceneObject->mVWrapMode[bufferIndex];
 237       break;
 238     }
 239     case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
 240     {
 241       value = mSceneObject->mAffectsTransparency[bufferIndex];
 242       break;
 243     }
 244   }
 245   return value;
 246 }
 247
 248 const SceneGraph::PropertyOwner* Sampler::GetPropertyOwner() const
 249 {
 250   return mSceneObject;
 251 }
 252
 253 const SceneGraph::PropertyOwner* Sampler::GetSceneObject() const
 254 {
 255   return mSceneObject;
 256 }
 257
 258 const SceneGraph::PropertyBase* Sampler::GetSceneObjectAnimatableProperty( Property::Index index ) const
 259 {
 260   DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
 261
 262   const SceneGraph::PropertyBase* property = NULL;
 263
 264   if( OnStage() )
 265   {
 266     property = SAMPLER_IMPL.GetRegisteredSceneGraphProperty( this,
 267                                                              &Sampler::FindAnimatableProperty,
 268                                                              &Sampler::FindCustomProperty,
 269                                                              index );
 270
 271     if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
 272     {
 273       // No animatable default props
 274       DALI_ASSERT_ALWAYS( 0 && "Property is not animatable" );
 275     }
 276   }
 277
 278   return property;
 279 }
 280
 281 const PropertyInputImpl* Sampler::GetSceneObjectInputProperty( Property::Index index ) const
 282 {
 283   const PropertyInputImpl* property = NULL;
 284
 285   if( OnStage() )
 286   {
 287     const SceneGraph::PropertyBase* baseProperty =
 288       SAMPLER_IMPL.GetRegisteredSceneGraphProperty( this,
 289                                                     &Sampler::FindAnimatableProperty,
 290                                                     &Sampler::FindCustomProperty,
 291                                                     index );
 292     property = static_cast<const PropertyInputImpl*>( baseProperty );
 293
 294     if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
 295     {
 296       switch( index )
 297       {
 298         case Dali::Sampler::Property::MINIFICATION_FILTER:
 299         {
 300           property = &mSceneObject->mMinFilter;
 301           break;
 302         }
 303         case Dali::Sampler::Property::MAGNIGICATION_FILTER:
 304         {
 305           property = &mSceneObject->mMagFilter;
 306           break;
 307         }
 308         case Dali::Sampler::Property::U_WRAP:
 309         {
 310           property = &mSceneObject->mUWrapMode;
 311           break;
 312         }
 313         case Dali::Sampler::Property::V_WRAP:
 314         {
 315           property = &mSceneObject->mVWrapMode;
 316           break;
 317         }
 318         case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
 319         {
 320           property = &mSceneObject->mAffectsTransparency;
 321           break;
 322         }
 323       }
 324     }
 325   }
 326
 327   return property;
 328 }
 329
 330 int Sampler::GetPropertyComponentIndex( Property::Index index ) const
 331 {
 332   return Property::INVALID_COMPONENT_INDEX;
 333 }
 334
 335 bool Sampler::OnStage() const
 336 {
 337   return mOnStage;
 338 }
 339
 340 void Sampler::Connect()
 341 {
 342   mOnStage = true;
 343
 344   mImageConnector.OnStageConnect();
 345
 346   // sceneObject is being used in a separate thread; queue a message to set
 347   unsigned int resourceId = mImageConnector.Get()->GetResourceId();
 348   SetTextureMessage( GetEventThreadServices(), *mSceneObject, resourceId );
 349 }
 350
 351 void Sampler::Disconnect()
 352 {
 353   mOnStage = false;
 354
 355   mImageConnector.OnStageDisconnect();
 356 }
 357
 358 Sampler::Sampler()
 359 : mSceneObject( NULL ),
 360   mOnStage( false )
 361 {
 362 }
 363
 364 void Sampler::Initialize( const std::string& textureUnitUniformName )
 365 {
 366   EventThreadServices& eventThreadServices = GetEventThreadServices();
 367   SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 368
 369   mSceneObject = new SceneGraph::Sampler( textureUnitUniformName );
 370   AddMessage( updateManager, updateManager.GetSamplerOwner(), *mSceneObject );
 371
 372   eventThreadServices.RegisterObject( this );
 373 }
 374
 375 Sampler::~Sampler()
 376 {
 377   if( EventThreadServices::IsCoreRunning() )
 378   {
 379     EventThreadServices& eventThreadServices = GetEventThreadServices();
 380     SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 381     RemoveMessage( updateManager, updateManager.GetSamplerOwner(), *mSceneObject );
 382
 383     eventThreadServices.UnregisterObject( this );
 384   }
 385 }
 386
 387 } // namespace Internal
 388 } // namespace Dali