/*
- * Copyright (c) 2016 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.
#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/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
#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( size_t index, TexturePtr texture )
+void TextureSet::SetTexture(uint32_t index, TexturePtr texture)
{
- size_t textureCount( 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( size_t i(textureCount); i<=index; ++i )
+ for(uint32_t i(textureCount); i <= index; ++i)
{
- mTextures[i] = NULL;
+ mTextures[i] = nullptr;
- if( !samplerExist )
+ if(!samplerExist)
{
- mSamplers[i] = NULL;
+ mSamplers[i] = nullptr;
}
}
}
- mTextures[index]= texture;
+ mTextures[index] = texture;
- Render::Texture* renderTexture(0);
- if( texture )
+ Render::Texture* renderTexture(nullptr);
+ if(texture)
{
renderTexture = texture->GetRenderObject();
}
- SceneGraph::SetTextureMessage( mEventThreadServices, *mSceneObject, index, renderTexture );
+ SceneGraph::SetTextureMessage(mEventThreadServices, *mSceneObject, index, renderTexture);
}
-Texture* TextureSet::GetTexture( size_t index ) const
+Texture* TextureSet::GetTexture(uint32_t index) const
{
- Texture* result(0);
- if( index < mTextures.size() )
+ Texture* result(nullptr);
+ 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( size_t index, SamplerPtr sampler )
+void TextureSet::SetSampler(uint32_t index, SamplerPtr sampler)
{
- size_t samplerCount( mSamplers.size() );
- if( samplerCount < index + 1 )
+ uint32_t samplerCount = static_cast<uint32_t>(mSamplers.size());
+ if(samplerCount < index + 1)
{
- mSamplers.resize( index + 1 );
- for( size_t i(samplerCount); i<=index; ++i )
+ mSamplers.resize(index + 1);
+ for(uint32_t i = samplerCount; i <= index; ++i)
{
- mSamplers[i] = NULL;
+ mSamplers[i] = nullptr;
}
}
mSamplers[index] = sampler;
- Render::Sampler* renderSampler(0);
- if( sampler )
+ Render::Sampler* renderSampler(nullptr);
+ if(sampler)
{
renderSampler = sampler->GetSamplerRenderObject();
}
- SceneGraph::SetSamplerMessage( mEventThreadServices, *mSceneObject, index, renderSampler );
+ SceneGraph::SetSamplerMessage(mEventThreadServices, *mSceneObject, index, renderSampler);
}
-Sampler* TextureSet::GetSampler( size_t index ) const
+Sampler* TextureSet::GetSampler(uint32_t index) const
{
- Sampler* result(0);
- if( index < mSamplers.size() )
+ Sampler* result(nullptr);
+ 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;
}
-size_t TextureSet::GetTextureCount() const
+uint32_t TextureSet::GetTextureCount() const
{
- return mTextures.size();
+ return static_cast<uint32_t>(mTextures.size());
}
const SceneGraph::TextureSet* TextureSet::GetTextureSetSceneObject() const
}
TextureSet::TextureSet()
-:mEventThreadServices( *Stage::GetCurrent() ),
- mSceneObject( NULL )
+: mEventThreadServices(EventThreadServices::Get()),
+ mSceneObject(nullptr)
{
}
SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
mSceneObject = SceneGraph::TextureSet::New();
- AddTextureSetMessage( updateManager, *mSceneObject );
+ 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);
}
}