dali/internal/event/rendering/material-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/material-impl.h> // Dali::Internal::Material
  20
  21 //EXTERNAL INCLUDES
  22 #include <string>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/object/type-registry.h>
  26 #include <dali/devel-api/rendering/material.h> // Dali::Internal::Material
  27 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
  28 #include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
  29 #include <dali/internal/update/manager/update-manager.h>
  30 #include <dali/internal/update/rendering/scene-graph-material.h>
  31
  32 namespace Dali
  33 {
  34 namespace Internal
  35 {
  36
  37 namespace
  38 {
  39
  40 const ObjectImplHelper<0> MATERIAL_IMPL = { NULL };
  41
  42 BaseHandle Create()
  43 {
  44   return Dali::BaseHandle();
  45 }
  46
  47 TypeRegistration mType( typeid( Dali::Material ), typeid( Dali::Handle ), Create );
  48
  49 } // unnamed namespace
  50
  51 MaterialPtr Material::New()
  52 {
  53   MaterialPtr material( new Material() );
  54   material->Initialize();
  55   return material;
  56 }
  57
  58 void Material::SetShader( Shader& shader )
  59 {
  60   DALI_ASSERT_DEBUG( mSceneObject )
  61   mShader = &shader;
  62
  63   SceneGraph::Shader& sceneGraphShader = *shader.GetShaderSceneObject();
  64   SceneGraph::SetShaderMessage( GetEventThreadServices(), *mSceneObject, sceneGraphShader );
  65 }
  66
  67 Shader* Material::GetShader() const
  68 {
  69   return mShader.Get();
  70 }
  71
  72 size_t Material::AddTexture( ImagePtr image, const std::string& uniformName, SamplerPtr sampler )
  73 {
  74   size_t index = mTextures.size();
  75   mTextures.push_back( Texture( uniformName, image, sampler ) );
  76
  77   Render::Sampler* renderSampler(0);
  78   if( sampler )
  79   {
  80     renderSampler = sampler->GetSamplerRenderObject();
  81   }
  82
  83   if( mOnStage )
  84   {
  85     image->Connect();
  86   }
  87
  88   SceneGraph::AddTextureMessage( GetEventThreadServices(), *mSceneObject, uniformName, image->GetResourceId(), renderSampler );
  89   return index;
  90 }
  91
  92 void Material::RemoveTexture( size_t index )
  93 {
  94   if( index < GetNumberOfTextures() )
  95   {
  96     mTextures.erase( mTextures.begin() + index );
  97     SceneGraph::RemoveTextureMessage( GetEventThreadServices(), *mSceneObject, index );
  98   }
  99 }
 100
 101 void Material::SetTextureImage( size_t index, Image* image )
 102 {
 103   if( index < GetNumberOfTextures() )
 104   {
 105     if( mTextures[index].mImage && mOnStage )
 106     {
 107       mTextures[index].mImage->Disconnect();
 108
 109       if( image )
 110       {
 111         image->Connect();
 112       }
 113     }
 114
 115     mTextures[index].mImage.Reset(image);
 116     SceneGraph::SetTextureImageMessage( GetEventThreadServices(), *mSceneObject, index, mTextures[index].mImage.Get()->GetResourceId() );
 117   }
 118 }
 119
 120 void Material::SetTextureSampler( size_t index, Sampler* sampler )
 121 {
 122   if( index < GetNumberOfTextures() )
 123   {
 124     mTextures[index].mSampler.Reset(sampler);
 125
 126     Render::Sampler* renderSampler(0);
 127     if( sampler )
 128     {
 129       renderSampler = sampler->GetSamplerRenderObject();
 130     }
 131     SceneGraph::SetTextureSamplerMessage( GetEventThreadServices(), *mSceneObject, index,  renderSampler );
 132   }
 133 }
 134
 135 Sampler* Material::GetTextureSampler( size_t index ) const
 136 {
 137   if( index < GetNumberOfTextures() )
 138   {
 139     return mTextures[index].mSampler.Get();
 140   }
 141
 142   return NULL;
 143 }
 144
 145 void Material::SetTextureUniformName( size_t index, const std::string& uniformName )
 146 {
 147   if( index < GetNumberOfTextures() )
 148   {
 149     mTextures[index].mUniformName = uniformName;
 150     SceneGraph::SetTextureUniformNameMessage( GetEventThreadServices(), *mSceneObject, index,  uniformName );
 151   }
 152 }
 153
 154 int Material::GetTextureIndex( const std::string& uniformName ) const
 155 {
 156   size_t textureCount(GetNumberOfTextures());
 157   for( size_t i(0); i<textureCount; ++i )
 158   {
 159     if( uniformName.compare( mTextures[i].mUniformName ) == 0 )
 160     {
 161       return i;
 162     }
 163   }
 164
 165   return -1;
 166 }
 167
 168 Image* Material::GetTexture( const std::string& uniformName ) const
 169 {
 170   int textureId = GetTextureIndex( uniformName );
 171   if( textureId != -1 )
 172   {
 173     return GetTexture( textureId );
 174   }
 175
 176   return NULL;
 177 }
 178
 179 Image* Material::GetTexture( size_t index ) const
 180 {
 181   if( index < GetNumberOfTextures() )
 182   {
 183     return mTextures[ index ].mImage.Get();
 184   }
 185
 186   return NULL;
 187 }
 188
 189 size_t Material::GetNumberOfTextures() const
 190 {
 191   return mTextures.size();
 192 }
 193
 194 const SceneGraph::Material* Material::GetMaterialSceneObject() const
 195 {
 196   return mSceneObject;
 197 }
 198
 199 unsigned int Material::GetDefaultPropertyCount() const
 200 {
 201   return MATERIAL_IMPL.GetDefaultPropertyCount();
 202 }
 203
 204 void Material::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
 205 {
 206   MATERIAL_IMPL.GetDefaultPropertyIndices( indices );
 207 }
 208
 209 const char* Material::GetDefaultPropertyName(Property::Index index) const
 210 {
 211   return MATERIAL_IMPL.GetDefaultPropertyName( index );
 212 }
 213
 214 Property::Index Material::GetDefaultPropertyIndex( const std::string& name ) const
 215 {
 216   return MATERIAL_IMPL.GetDefaultPropertyIndex( name );
 217 }
 218
 219 bool Material::IsDefaultPropertyWritable( Property::Index index ) const
 220 {
 221   return MATERIAL_IMPL.IsDefaultPropertyWritable( index );
 222 }
 223
 224 bool Material::IsDefaultPropertyAnimatable( Property::Index index ) const
 225 {
 226   return MATERIAL_IMPL.IsDefaultPropertyAnimatable( index );
 227 }
 228
 229 bool Material::IsDefaultPropertyAConstraintInput( Property::Index index ) const
 230 {
 231   return MATERIAL_IMPL.IsDefaultPropertyAConstraintInput( index );
 232 }
 233
 234 Property::Type Material::GetDefaultPropertyType( Property::Index index ) const
 235 {
 236   return MATERIAL_IMPL.GetDefaultPropertyType( index );
 237 }
 238
 239 void Material::SetDefaultProperty( Property::Index index,
 240                                    const Property::Value& propertyValue )
 241 {
 242 }
 243
 244 void Material::SetSceneGraphProperty( Property::Index index,
 245                                       const PropertyMetadata& entry,
 246                                       const Property::Value& value )
 247 {
 248   MATERIAL_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
 249   OnPropertySet(index, value);
 250 }
 251
 252 Property::Value Material::GetDefaultProperty( Property::Index index ) const
 253 {
 254   Property::Value value;
 255   return value;
 256 }
 257
 258 const SceneGraph::PropertyOwner* Material::GetPropertyOwner() const
 259 {
 260   return mSceneObject;
 261 }
 262
 263 const SceneGraph::PropertyOwner* Material::GetSceneObject() const
 264 {
 265   return mSceneObject;
 266 }
 267
 268 const SceneGraph::PropertyBase* Material::GetSceneObjectAnimatableProperty( Property::Index index ) const
 269 {
 270   PropertyMetadata* property = index >= PROPERTY_CUSTOM_START_INDEX ? static_cast<PropertyMetadata*>(FindCustomProperty( index )) : static_cast<PropertyMetadata*>(FindAnimatableProperty( index ));
 271   DALI_ASSERT_ALWAYS( property && "Property index is invalid" );
 272   return property->GetSceneGraphProperty();
 273 }
 274
 275 const PropertyInputImpl* Material::GetSceneObjectInputProperty( Property::Index index ) const
 276 {
 277   return GetSceneObjectAnimatableProperty( index );
 278 }
 279
 280 int Material::GetPropertyComponentIndex( Property::Index index ) const
 281 {
 282   return Property::INVALID_COMPONENT_INDEX;
 283 }
 284
 285 bool Material::OnStage() const
 286 {
 287   return mOnStage;
 288 }
 289
 290 void Material::Connect()
 291 {
 292   mOnStage = true;
 293
 294   for( size_t i(0); i<mTextures.size(); ++i )
 295   {
 296     if( mTextures[i].mImage )
 297     {
 298       mTextures[i].mImage->Connect();
 299       if( mTextures[i].mImage->GetResourceId() != 0 )
 300       {
 301         SceneGraph::SetTextureImageMessage( GetEventThreadServices(), *mSceneObject, i, mTextures[i].mImage->GetResourceId() );
 302       }
 303     }
 304   }
 305 }
 306
 307 void Material::Disconnect()
 308 {
 309   for( size_t i(0); i<mTextures.size(); ++i )
 310   {
 311     if( mTextures[i].mImage )
 312     {
 313       mTextures[i].mImage->Disconnect();
 314     }
 315   }
 316
 317   mOnStage = false;
 318 }
 319
 320 Material::Material()
 321 : mSceneObject( NULL ),
 322   mShader( NULL ),
 323   mTextures(),
 324   mOnStage( false )
 325 {
 326 }
 327
 328 void Material::Initialize()
 329 {
 330   EventThreadServices& eventThreadServices = GetEventThreadServices();
 331   SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 332
 333   mSceneObject = SceneGraph::Material::New();
 334   AddMessage( updateManager, updateManager.GetMaterialOwner(), *mSceneObject );
 335
 336   eventThreadServices.RegisterObject( this );
 337 }
 338
 339 Material::~Material()
 340 {
 341   if( EventThreadServices::IsCoreRunning() )
 342   {
 343     EventThreadServices& eventThreadServices = GetEventThreadServices();
 344     SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
 345     RemoveMessage( updateManager, updateManager.GetMaterialOwner(), *mSceneObject );
 346
 347     eventThreadServices.UnregisterObject( this );
 348   }
 349 }
 350
 351 } // namespace Internal
 352 } // namespace Dali