Merge branch 'devel/master' into tizen

[platform/core/uifw/dali-core.git] / dali / internal / event / rendering / texture-set-impl.cpp

diff --git a/dali/internal/event/rendering/texture-set-impl.cpp b/dali/internal/event/rendering/texture-set-impl.cpp
index 373daaf..f7b4ab0 100644 (file)
--- a/dali/internal/event/rendering/texture-set-impl.cpp
+++ b/dali/internal/event/rendering/texture-set-impl.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,80 +19,79 @@
 #include <dali/internal/event/rendering/texture-set-impl.h> // Dali::Internal::TextureSet
 
 // INTERNAL INCLUDES
-#include <dali/public-api/object/type-registry.h>
 #include <dali/internal/update/manager/update-manager.h>
 #include <dali/internal/update/rendering/scene-graph-texture-set.h>
+#include <dali/public-api/object/type-registry.h>
 
 namespace Dali
 {
 namespace Internal
 {
-
 TextureSetPtr TextureSet::New()
 {
-  TextureSetPtr textureSet( new TextureSet() );
+  TextureSetPtr textureSet(new TextureSet());
   textureSet->Initialize();
   return textureSet;
 }
 
-void TextureSet::SetTexture( uint32_t index, TexturePtr texture )
+void TextureSet::SetTexture(uint32_t index, TexturePtr texture)
 {
-  uint32_t textureCount = static_cast<uint32_t>( mTextures.size() );
-  if( index >= textureCount )
+  uint32_t textureCount = static_cast<uint32_t>(mTextures.size());
+  if(index >= textureCount)
   {
     mTextures.resize(index + 1);
 
     bool samplerExist = true;
-    if( mSamplers.size() < index + 1 )
+    if(mSamplers.size() < index + 1)
     {
-      mSamplers.resize( index + 1 );
+      mSamplers.resize(index + 1);
       samplerExist = false;
     }
 
-    for( uint32_t i(textureCount); i<=index; ++i )
+    for(uint32_t i(textureCount); i <= index; ++i)
     {
       mTextures[i] = nullptr;
 
-      if( !samplerExist )
+      if(!samplerExist)
       {
         mSamplers[i] = nullptr;
       }
     }
   }
 
-  mTextures[index]= texture;
+  mTextures[index] = texture;
 
   Render::Texture* renderTexture(nullptr);
-  if( texture )
+  if(texture)
   {
     renderTexture = texture->GetRenderObject();
   }
 
-  SceneGraph::SetTextureMessage( mEventThreadServices, *mSceneObject, index, renderTexture );
+  SceneGraph::SetTextureMessage(mEventThreadServices, *mSceneObject, index, renderTexture);
 }
 
-Texture* TextureSet::GetTexture( uint32_t index ) const
+Texture* TextureSet::GetTexture(uint32_t index) const
 {
   Texture* result(nullptr);
-  if( index < mTextures.size() )
+  if(index < mTextures.size())
   {
     result = mTextures[index].Get();
   }
   else
   {
-    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetTexture\n");
+    DALI_LOG_ERROR("Error: Invalid index to TextureSet::GetTexture\n");
   }
 
   return result;
 }
 
-void TextureSet::SetSampler( uint32_t index, SamplerPtr sampler )
+void TextureSet::SetSampler(uint32_t index, SamplerPtr sampler)
 {
-  uint32_t samplerCount = static_cast<uint32_t>( mSamplers.size() );
-  if( samplerCount < index + 1  )
+  uint32_t samplerCount = static_cast<uint32_t>(mSamplers.size());
+  if(samplerCount < index + 1)
   {
-    mSamplers.resize( index + 1 );
-    for( uint32_t i = samplerCount; i<=index; ++i )
+    mSamplers.resize(index + 1);
+    for(uint32_t i = samplerCount; i <= index; ++i)
     {
       mSamplers[i] = nullptr;
     }
@@ -101,24 +100,24 @@ void TextureSet::SetSampler( uint32_t index, SamplerPtr sampler )
   mSamplers[index] = sampler;
 
   Render::Sampler* renderSampler(nullptr);
-  if( sampler )
+  if(sampler)
   {
     renderSampler = sampler->GetSamplerRenderObject();
   }
 
-  SceneGraph::SetSamplerMessage( mEventThreadServices, *mSceneObject, index, renderSampler );
+  SceneGraph::SetSamplerMessage(mEventThreadServices, *mSceneObject, index, renderSampler);
 }
 
-Sampler* TextureSet::GetSampler( uint32_t index ) const
+Sampler* TextureSet::GetSampler(uint32_t index) const
 {
   Sampler* result(nullptr);
-  if( index < mSamplers.size() )
+  if(index < mSamplers.size())
   {
     result = mSamplers[index].Get();
   }
   else
   {
-    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler\n");
+    DALI_LOG_ERROR("Error: Invalid index to TextureSet::GetSampler\n");
   }
 
   return result;
@@ -126,7 +125,7 @@ Sampler* TextureSet::GetSampler( uint32_t index ) const
 
 uint32_t TextureSet::GetTextureCount() const
 {
-  return static_cast<uint32_t>( mTextures.size() );
+  return static_cast<uint32_t>(mTextures.size());
 }
 
 const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
@@ -135,8 +134,8 @@ const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
 }
 
 TextureSet::TextureSet()
-:mEventThreadServices( EventThreadServices::Get() ),
- mSceneObject( nullptr )
+: mEventThreadServices(EventThreadServices::Get()),
+  mSceneObject(nullptr)
 {
 }
 
@@ -145,16 +144,16 @@ void TextureSet::Initialize()
   SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
 
   mSceneObject = SceneGraph::TextureSet::New();
-  OwnerPointer< SceneGraph::TextureSet > transferOwnership( mSceneObject );
-  AddTextureSetMessage( updateManager, transferOwnership );
+  OwnerPointer<SceneGraph::TextureSet> transferOwnership(mSceneObject);
+  AddTextureSetMessage(updateManager, transferOwnership);
 }
 
 TextureSet::~TextureSet()
 {
-  if( EventThreadServices::IsCoreRunning() )
+  if(EventThreadServices::IsCoreRunning())
   {
     SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
-    RemoveTextureSetMessage( updateManager, *mSceneObject );
+    RemoveTextureSetMessage(updateManager, *mSceneObject);
   }
 }