/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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-extension/vector-animation-renderer/tizen-vector-animation-manager.h>
// EXTERNAL INCLUDES
-#include <dali/integration-api/debug.h>
#include <dali/integration-api/adaptor-framework/adaptor.h>
+#include <dali/integration-api/debug.h>
namespace Dali
{
-
namespace Plugin
{
+namespace
+{
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
+#endif
+} // unnamed namespace
TizenVectorAnimationManager& TizenVectorAnimationManager::Get()
{
TizenVectorAnimationManager::~TizenVectorAnimationManager()
{
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationManager::~TizenVectorAnimationManager: this = %p\n", this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "this = %p\n", this);
}
-void TizenVectorAnimationManager::AddEventHandler( TizenVectorAnimationEventHandler& handler )
+void TizenVectorAnimationManager::AddEventHandler(TizenVectorAnimationEventHandler& handler)
{
- if( mEventHandlers.end() == std::find( mEventHandlers.begin(), mEventHandlers.end(), &handler ) )
+ if(mEventHandlers.end() == std::find(mEventHandlers.begin(), mEventHandlers.end(), &handler))
{
- if( mEventHandlers.empty() )
+ if(mEventHandlers.empty())
{
- Adaptor::Get().RegisterProcessor( *this );
+ Adaptor::Get().RegisterProcessor(*this);
}
- mEventHandlers.push_back( &handler );
+ mEventHandlers.push_back(&handler);
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( !mEventTrigger )
+ if(!mEventTrigger)
{
- mEventTrigger = std::unique_ptr< EventThreadCallback >( new EventThreadCallback( MakeCallback( this, &TizenVectorAnimationManager::OnEventTriggered ) ) );
+ mEventTrigger = std::unique_ptr<EventThreadCallback>(new EventThreadCallback(MakeCallback(this, &TizenVectorAnimationManager::OnEventTriggered)));
}
}
}
}
-void TizenVectorAnimationManager::RemoveEventHandler( TizenVectorAnimationEventHandler& handler )
+void TizenVectorAnimationManager::RemoveEventHandler(TizenVectorAnimationEventHandler& handler)
{
- auto iter = std::find( mEventHandlers.begin(), mEventHandlers.end(), &handler );
- if( iter != mEventHandlers.end() )
+ auto iter = std::find(mEventHandlers.begin(), mEventHandlers.end(), &handler);
+ if(iter != mEventHandlers.end())
{
- mEventHandlers.erase( iter );
+ mEventHandlers.erase(iter);
}
bool releaseEventTrigger = false;
- if( mEventHandlers.empty() )
+ if(mEventHandlers.empty())
{
- if( Adaptor::IsAvailable() )
+ if(Adaptor::IsAvailable())
{
- Adaptor::Get().UnregisterProcessor( *this );
+ Adaptor::Get().UnregisterProcessor(*this);
}
releaseEventTrigger = true;
}
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- auto triggeredHandler = std::find( mTriggeredHandlers.begin(), mTriggeredHandlers.end(), &handler );
- if( triggeredHandler != mTriggeredHandlers.end() )
+ auto triggeredHandler = std::find(mTriggeredHandlers.begin(), mTriggeredHandlers.end(), &handler);
+ if(triggeredHandler != mTriggeredHandlers.end())
{
- mTriggeredHandlers.erase( triggeredHandler );
+ mTriggeredHandlers.erase(triggeredHandler);
}
- if( releaseEventTrigger )
+ if(releaseEventTrigger)
{
mEventTrigger.reset();
}
}
}
-void TizenVectorAnimationManager::TriggerEvent( TizenVectorAnimationEventHandler& handler )
+void TizenVectorAnimationManager::TriggerEvent(TizenVectorAnimationEventHandler& handler)
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( mTriggeredHandlers.end() == std::find( mTriggeredHandlers.begin(), mTriggeredHandlers.end(), &handler ) )
+ if(mTriggeredHandlers.end() == std::find(mTriggeredHandlers.begin(), mTriggeredHandlers.end(), &handler))
{
- mTriggeredHandlers.push_back( &handler );
+ mTriggeredHandlers.push_back(&handler);
- if( mEventTrigger )
+ if(mEventTrigger)
{
mEventTrigger->Trigger();
}
// This function is called in the main thread.
void TizenVectorAnimationManager::OnEventTriggered()
{
- std::vector< TizenVectorAnimationEventHandler* > handlers;
+ std::vector<TizenVectorAnimationEventHandler*> handlers;
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
// Copy the list to the local variable and clear
handlers = mTriggeredHandlers;
mTriggeredHandlers.clear();
}
- for( auto&& iter : handlers )
+ for(auto&& iter : handlers)
{
// Check if it is valid
- auto handler = std::find( mEventHandlers.begin(), mEventHandlers.end(), iter );
- if( handler != mEventHandlers.end() )
+ auto handler = std::find(mEventHandlers.begin(), mEventHandlers.end(), iter);
+ if(handler != mEventHandlers.end())
{
iter->NotifyEvent();
}
} // namespace Plugin
-} // namespace Dali;
+} // namespace Dali
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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-extension/vector-animation-renderer/tizen-vector-animation-renderer.h>
// EXTERNAL INCLUDES
-#include <dali/public-api/object/property-array.h>
-#include <dali/integration-api/debug.h>
#include <dali/devel-api/adaptor-framework/native-image-source-queue.h>
-#include <cstring> // for strlen()
+#include <dali/integration-api/debug.h>
+#include <dali/public-api/object/property-array.h>
#include <tbm_surface_internal.h>
+#include <cstring> // for strlen()
// INTERNAL INCLUDES
#include <dali-extension/vector-animation-renderer/tizen-vector-animation-manager.h>
// The plugin factories
-extern "C" DALI_EXPORT_API Dali::VectorAnimationRendererPlugin* CreateVectorAnimationRendererPlugin( void )
+extern "C" DALI_EXPORT_API Dali::VectorAnimationRendererPlugin* CreateVectorAnimationRendererPlugin(void)
{
return new Dali::Plugin::TizenVectorAnimationRenderer;
}
namespace Dali
{
-
namespace Plugin
{
-
namespace
{
+const char* const PIXEL_AREA_UNIFORM_NAME("pixelArea");
+const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
-const char* const PIXEL_AREA_UNIFORM_NAME( "pixelArea" );
-
-const Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
-
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gVectorAnimationLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_VECTOR_ANIMATION");
+#endif
} // unnamed namespace
TizenVectorAnimationRenderer::TizenVectorAnimationRenderer()
mTargetSurface(),
mVectorRenderer(),
mUploadCompletedSignal(),
- mTbmQueue( NULL ),
- mTotalFrameNumber( 0 ),
- mWidth( 0 ),
- mHeight( 0 ),
- mDefaultWidth( 0 ),
- mDefaultHeight( 0 ),
- mFrameRate( 60.0f ),
- mResourceReady( false ),
- mShaderChanged( false ),
- mResourceReadyTriggered( false )
+ mTbmQueue(NULL),
+ mTotalFrameNumber(0),
+ mWidth(0),
+ mHeight(0),
+ mDefaultWidth(0),
+ mDefaultHeight(0),
+ mFrameRate(60.0f),
+ mLoadFailed(false),
+ mResourceReady(false),
+ mShaderChanged(false),
+ mResourceReadyTriggered(false)
{
+ TizenVectorAnimationManager::Get().AddEventHandler(*this);
}
TizenVectorAnimationRenderer::~TizenVectorAnimationRenderer()
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
ResetBuffers();
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::~TizenVectorAnimationRenderer: this = %p\n", this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "this = %p\n", this);
}
void TizenVectorAnimationRenderer::Finalize()
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- TizenVectorAnimationManager::Get().RemoveEventHandler( *this );
+ TizenVectorAnimationManager::Get().RemoveEventHandler(*this);
mRenderer.Reset();
mTexture.Reset();
mVectorRenderer.reset();
mTargetSurface = nullptr;
- mTbmQueue = NULL;
+ mTbmQueue = NULL;
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::Finalize: [%p]\n", this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "[%p]\n", this);
}
-bool TizenVectorAnimationRenderer::Load(const std::string &url)
+bool TizenVectorAnimationRenderer::Load(const std::string& url)
{
mUrl = url;
- mVectorRenderer = rlottie::Animation::loadFromFile( mUrl );
- if( !mVectorRenderer )
+ mVectorRenderer = rlottie::Animation::loadFromFile(mUrl);
+ if(!mVectorRenderer)
{
- DALI_LOG_ERROR( "Failed to load a Lottie file [%s] [%p]\n", mUrl.c_str(), this );
+ DALI_LOG_ERROR("Failed to load a Lottie file [%s] [%p]\n", mUrl.c_str(), this);
+ mLoadFailed = true;
return false;
}
mTotalFrameNumber = mVectorRenderer->totalFrame();
- mFrameRate = static_cast< float >( mVectorRenderer->frameRate() );
+ mFrameRate = static_cast<float>(mVectorRenderer->frameRate());
size_t w, h;
- mVectorRenderer->size( w, h );
- mDefaultWidth = static_cast< uint32_t >( w );
- mDefaultHeight = static_cast< uint32_t >( h );
+ mVectorRenderer->size(w, h);
+ mDefaultWidth = static_cast<uint32_t>(w);
+ mDefaultHeight = static_cast<uint32_t>(h);
- TizenVectorAnimationManager::Get().AddEventHandler( *this );
-
- DALI_LOG_RELEASE_INFO("TizenVectorAnimationRenderer::Load: file [%s] [%p]\n", url.c_str(), this);
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "file [%s] [%p]\n", url.c_str(), this);
return true;
}
-void TizenVectorAnimationRenderer::SetRenderer( Renderer renderer )
+void TizenVectorAnimationRenderer::SetRenderer(Renderer renderer)
{
- mRenderer = renderer;
+ mRenderer = renderer;
mShaderChanged = false;
- if( mTargetSurface )
+ if(mTargetSurface)
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( mResourceReady && mRenderedTexture )
+ if(mResourceReady && mRenderedTexture)
{
TextureSet textureSet = renderer.GetTextures();
- textureSet.SetTexture( 0, mRenderedTexture );
+ textureSet.SetTexture(0, mRenderedTexture);
mUploadCompletedSignal.Emit();
}
}
}
-void TizenVectorAnimationRenderer::SetSize( uint32_t width, uint32_t height )
+void TizenVectorAnimationRenderer::SetSize(uint32_t width, uint32_t height)
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
+
+ if(mWidth == width && mHeight == height)
+ {
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "Same size (%d, %d) [%p]\n", mWidth, mHeight, this);
+ return;
+ }
- if( mWidth == width && mHeight == height )
+ if(mLoadFailed)
{
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::SetSize: Same size (%d, %d) [%p]\n", mWidth, mHeight, this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "Load is failed. Do not make texture [%p]\n", this);
return;
}
- mTargetSurface = NativeImageSourceQueue::New( width, height, NativeImageSourceQueue::ColorFormat::RGBA8888 );
+ mTargetSurface = NativeImageSourceQueue::New(width, height, NativeImageSourceQueue::ColorFormat::RGBA8888);
- mTexture = Texture::New( *mTargetSurface );
+ mTexture = Texture::New(*mTargetSurface);
- if( mRenderer )
+ if(mRenderer)
{
SetShader();
}
- mTbmQueue = AnyCast< tbm_surface_queue_h >( mTargetSurface->GetNativeImageSourceQueue() );
+ mTbmQueue = AnyCast<tbm_surface_queue_h>(mTargetSurface->GetNativeImageSourceQueue());
- mWidth = width;
+ mWidth = width;
mHeight = height;
mResourceReady = false;
// Reset the previous texture to destroy it in the main thread
mPreviousTexture.Reset();
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::SetSize: width = %d, height = %d [%p]\n", mWidth, mHeight, this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "width = %d, height = %d [%p]\n", mWidth, mHeight, this);
}
-bool TizenVectorAnimationRenderer::Render( uint32_t frameNumber )
+bool TizenVectorAnimationRenderer::Render(uint32_t frameNumber)
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( !mTbmQueue || !mVectorRenderer || !mTargetSurface )
+ if(!mTbmQueue || !mVectorRenderer || !mTargetSurface)
{
return false;
}
- int canDequeue = tbm_surface_queue_can_dequeue( mTbmQueue, 0 );
- if( !canDequeue )
+ int canDequeue = tbm_surface_queue_can_dequeue(mTbmQueue, 0);
+ if(!canDequeue)
{
// Ignore the previous image which is inserted to the queue.
mTargetSurface->IgnoreSourceImage();
// Check again
- canDequeue = tbm_surface_queue_can_dequeue( mTbmQueue, 0 );
- if( !canDequeue )
+ canDequeue = tbm_surface_queue_can_dequeue(mTbmQueue, 0);
+ if(!canDequeue)
{
return false;
}
tbm_surface_h tbmSurface;
- if( tbm_surface_queue_dequeue( mTbmQueue, &tbmSurface ) != TBM_SURFACE_QUEUE_ERROR_NONE )
+ if(tbm_surface_queue_dequeue(mTbmQueue, &tbmSurface) != TBM_SURFACE_QUEUE_ERROR_NONE)
{
- DALI_LOG_ERROR( "Failed to dequeue a tbm_surface [%p]\n", this );
+ DALI_LOG_ERROR("Failed to dequeue a tbm_surface [%p]\n", this);
return false;
}
tbm_surface_info_s info;
- int ret = tbm_surface_map( tbmSurface, TBM_OPTION_WRITE, &info );
- if( ret != TBM_SURFACE_ERROR_NONE )
+ int ret = tbm_surface_map(tbmSurface, TBM_OPTION_WRITE, &info);
+ if(ret != TBM_SURFACE_ERROR_NONE)
{
- DALI_LOG_ERROR( "TizenVectorAnimationRenderer::Render: tbm_surface_map is failed! [%d] [%p]\n", ret, this );
- tbm_surface_queue_cancel_dequeue( mTbmQueue, tbmSurface );
+ DALI_LOG_ERROR("TizenVectorAnimationRenderer::Render: tbm_surface_map is failed! [%d] [%p]\n", ret, this);
+ tbm_surface_queue_cancel_dequeue(mTbmQueue, tbmSurface);
return false;
}
unsigned char* buffer = info.planes[0].ptr;
- if( info.width != mWidth || info.height != mHeight || !buffer )
+ if(info.width != mWidth || info.height != mHeight || !buffer)
{
- DALI_LOG_ERROR( "TizenVectorAnimationRenderer::Render: Invalid tbm surface! [%d, %d, %p] [%p]\n", info.width, info.height, buffer, this );
- tbm_surface_unmap( tbmSurface );
- tbm_surface_queue_cancel_dequeue( mTbmQueue, tbmSurface );
+ DALI_LOG_ERROR("TizenVectorAnimationRenderer::Render: Invalid tbm surface! [%d, %d, %p] [%p]\n", info.width, info.height, buffer, this);
+ tbm_surface_unmap(tbmSurface);
+ tbm_surface_queue_cancel_dequeue(mTbmQueue, tbmSurface);
return false;
}
rlottie::Surface surface;
- bool existing = false;
+ bool existing = false;
- if( !mResourceReady )
+ if(!mResourceReady)
{
// Need to reset buffer list
ResetBuffers();
}
else
{
- for( auto&& iter : mBuffers )
+ for(auto&& iter : mBuffers)
{
- if( iter.first == tbmSurface )
+ if(iter.first == tbmSurface)
{
// Find the buffer in the existing list
existing = true;
- surface = iter.second;
+ surface = iter.second;
break;
}
}
}
- if( !existing )
+ if(!existing)
{
- tbm_surface_internal_ref( tbmSurface );
+ tbm_surface_internal_ref(tbmSurface);
// Create Surface object
- surface = rlottie::Surface( reinterpret_cast< uint32_t* >( buffer ), mWidth, mHeight, static_cast< size_t >( info.planes[0].stride ) );
+ surface = rlottie::Surface(reinterpret_cast<uint32_t*>(buffer), mWidth, mHeight, static_cast<size_t>(info.planes[0].stride));
// Push the buffer
- mBuffers.push_back( SurfacePair( tbmSurface, surface ) );
+ mBuffers.push_back(SurfacePair(tbmSurface, surface));
}
// Render the frame
- mVectorRenderer->renderSync( frameNumber, surface );
+ mVectorRenderer->renderSync(frameNumber, surface);
- tbm_surface_unmap( tbmSurface );
+ tbm_surface_unmap(tbmSurface);
- tbm_surface_queue_enqueue( mTbmQueue, tbmSurface );
+ tbm_surface_queue_enqueue(mTbmQueue, tbmSurface);
- if( !mResourceReady )
+ if(!mResourceReady)
{
- mPreviousTexture = mRenderedTexture; // It is used to destroy the object in the main thread.
- mRenderedTexture = mTexture;
- mResourceReady = true;
+ mPreviousTexture = mRenderedTexture; // It is used to destroy the object in the main thread.
+ mRenderedTexture = mTexture;
+ mResourceReady = true;
mResourceReadyTriggered = true;
- TizenVectorAnimationManager::Get().TriggerEvent( *this );
+ TizenVectorAnimationManager::Get().TriggerEvent(*this);
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::Render: Resource ready [current = %d] [%p]\n", frameNumber, this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "Resource ready [current = %d] [%p]\n", frameNumber, this);
}
return true;
return mFrameRate;
}
-void TizenVectorAnimationRenderer::GetDefaultSize( uint32_t& width, uint32_t& height ) const
+void TizenVectorAnimationRenderer::GetDefaultSize(uint32_t& width, uint32_t& height) const
{
- width = mDefaultWidth;
+ width = mDefaultWidth;
height = mDefaultHeight;
}
-void TizenVectorAnimationRenderer::GetLayerInfo( Property::Map& map ) const
+void TizenVectorAnimationRenderer::GetLayerInfo(Property::Map& map) const
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( mVectorRenderer )
+ if(mVectorRenderer)
{
auto layerInfo = mVectorRenderer->layers();
- for( auto&& iter : layerInfo )
+ for(auto&& iter : layerInfo)
{
Property::Array frames;
- frames.PushBack( std::get< 1 >( iter ) );
- frames.PushBack( std::get< 2 >( iter ) );
- map.Add( std::get< 0 >( iter ), frames );
+ frames.PushBack(std::get<1>(iter));
+ frames.PushBack(std::get<2>(iter));
+ map.Add(std::get<0>(iter), frames);
}
}
}
-bool TizenVectorAnimationRenderer::GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const
+bool TizenVectorAnimationRenderer::GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( mVectorRenderer )
+ if(mVectorRenderer)
{
auto markerList = mVectorRenderer->markers();
- for( auto&& iter : markerList )
+ for(auto&& iter : markerList)
{
- if( std::get< 0 >( iter ).compare( marker ) == 0 )
+ if(std::get<0>(iter).compare(marker) == 0)
{
- startFrame = static_cast< uint32_t >( std::get< 1 >( iter ) );
- endFrame = static_cast< uint32_t >( std::get< 2 >( iter ) );
+ startFrame = static_cast<uint32_t>(std::get<1>(iter));
+ endFrame = static_cast<uint32_t>(std::get<2>(iter));
return true;
}
}
return false;
}
-void TizenVectorAnimationRenderer::IgnoreRenderedFrame()
+void TizenVectorAnimationRenderer::InvalidateBuffer()
{
- Dali::Mutex::ScopedLock lock( mMutex );
-
- if( mTargetSurface )
- {
- mTargetSurface->IgnoreSourceImage();
- }
+ Dali::Mutex::ScopedLock lock(mMutex);
+ mResourceReady = false;
}
VectorAnimationRendererPlugin::UploadCompletedSignalType& TizenVectorAnimationRenderer::UploadCompletedSignal()
void TizenVectorAnimationRenderer::NotifyEvent()
{
- Dali::Mutex::ScopedLock lock( mMutex );
+ Dali::Mutex::ScopedLock lock(mMutex);
- if( mResourceReadyTriggered )
+ if(mResourceReadyTriggered)
{
- DALI_LOG_RELEASE_INFO( "TizenVectorAnimationRenderer::NotifyEvent: Set Texture [%p]\n", this );
+ DALI_LOG_INFO(gVectorAnimationLogFilter, Debug::Verbose, "Set Texture [%p]\n", this);
// Set texture
- if( mRenderer && mRenderedTexture )
+ if(mRenderer && mRenderedTexture)
{
TextureSet textureSet = mRenderer.GetTextures();
- textureSet.SetTexture( 0, mRenderedTexture );
+ textureSet.SetTexture(0, mRenderedTexture);
}
mResourceReadyTriggered = false;
void TizenVectorAnimationRenderer::SetShader()
{
- if( mShaderChanged )
+ if(mShaderChanged)
{
return;
}
std::string vertexShader;
// Get the current fragment shader source
- Property::Value program = shader.GetProperty( Shader::Property::PROGRAM );
- Property::Map* map = program.GetMap();
- if( map )
+ Property::Value program = shader.GetProperty(Shader::Property::PROGRAM);
+ Property::Map* map = program.GetMap();
+ if(map)
{
- Property::Value* fragment = map->Find( "fragment" );
- if( fragment )
+ Property::Value* fragment = map->Find("fragment");
+ if(fragment)
{
- fragmentShader = fragment->Get< std::string >();
+ fragmentShader = fragment->Get<std::string>();
}
- Property::Value* vertex = map->Find( "vertex" );
- if( vertex )
+ Property::Value* vertex = map->Find("vertex");
+ if(vertex)
{
- vertexShader = vertex->Get< std::string >();
+ vertexShader = vertex->Get<std::string>();
}
}
mTargetSurface->ApplyNativeFragmentShader(fragmentShader);
// Set the modified shader again
- Shader newShader = Shader::New( vertexShader, fragmentShader );
- newShader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ Shader newShader = Shader::New(vertexShader, fragmentShader);
+ newShader.RegisterProperty(PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT);
- mRenderer.SetShader( newShader );
+ mRenderer.SetShader(newShader);
mShaderChanged = true;
}
void TizenVectorAnimationRenderer::ResetBuffers()
{
- for( auto&& iter : mBuffers )
+ for(auto&& iter : mBuffers)
{
- tbm_surface_internal_unref( iter.first );
+ tbm_surface_internal_unref(iter.first);
}
mBuffers.clear();
}
} // namespace Plugin
-} // namespace Dali;
+} // namespace Dali
#define DALI_TIZEN_VECTOR_ANIMATION_RENDERER_PLUGIN_H
/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/devel-api/threading/mutex.h>
#include <dali/devel-api/adaptor-framework/native-image-source-queue.h>
#include <dali/devel-api/adaptor-framework/vector-animation-renderer-plugin.h>
-#include <memory>
+#include <dali/devel-api/threading/mutex.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <rlottie.h>
#include <tbm_surface.h>
#include <tbm_surface_queue.h>
+#include <memory>
// INTERNAL INCLUDES
#include <dali-extension/vector-animation-renderer/tizen-vector-animation-event-handler.h>
namespace Dali
{
-
namespace Plugin
{
-
/**
* @brief Implementation of the Tizen vector animation renderer class which has Tizen platform dependency.
*/
class TizenVectorAnimationRenderer : public Dali::VectorAnimationRendererPlugin, public TizenVectorAnimationEventHandler
{
public:
-
/**
* @brief Constructor.
*/
/**
* @copydoc Dali::VectorAnimationRendererPlugin::Load()
*/
- bool Load(const std::string &url) override;
+ bool Load(const std::string& url) override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::SetRenderer()
*/
- void SetRenderer( Renderer renderer ) override;
+ void SetRenderer(Renderer renderer) override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::SetSize()
*/
- void SetSize( uint32_t width, uint32_t height ) override;
+ void SetSize(uint32_t width, uint32_t height) override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::Render()
*/
- bool Render( uint32_t frameNumber ) override;
+ bool Render(uint32_t frameNumber) override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::GetTotalFrameNumber()
/**
* @copydoc Dali::VectorAnimationRendererPlugin::GetDefaultSize()
*/
- void GetDefaultSize( uint32_t& width, uint32_t& height ) const override;
+ void GetDefaultSize(uint32_t& width, uint32_t& height) const override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::GetLayerInfo()
*/
- void GetLayerInfo( Property::Map& map ) const override;
+ void GetLayerInfo(Property::Map& map) const override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::GetMarkerInfo()
*/
- bool GetMarkerInfo( const std::string& marker, uint32_t& startFrame, uint32_t& endFrame ) const override;
+ bool GetMarkerInfo(const std::string& marker, uint32_t& startFrame, uint32_t& endFrame) const override;
/**
- * @copydoc Dali::VectorAnimationRendererPlugin::IgnoreRenderedFrame()
+ * @copydoc Dali::VectorAnimationRendererPlugin::InvalidateBuffer()
*/
- void IgnoreRenderedFrame() override;
+ void InvalidateBuffer() override;
/**
* @copydoc Dali::VectorAnimationRendererPlugin::UploadCompletedSignal()
UploadCompletedSignalType& UploadCompletedSignal() override;
protected: // Implementation of TizenVectorAnimationEventHandler
-
/**
* @copydoc Dali::Plugin::TizenVectorAnimationEventHandler::NotifyEvent()
*/
void NotifyEvent() override;
private:
-
/**
* @brief Set shader for NativeImageSourceQueue with custom sampler type and prefix.
*/
void ResetBuffers();
private:
-
- using SurfacePair = std::pair< tbm_surface_h, rlottie::Surface >;
-
- std::string mUrl; ///< The content file path
- std::vector< SurfacePair > mBuffers; ///< EGL Image vector
- mutable Dali::Mutex mMutex; ///< Mutex
- Dali::Renderer mRenderer; ///< Renderer
- Dali::Texture mTexture; ///< Texture
- Dali::Texture mRenderedTexture; ///< Rendered Texture
- Dali::Texture mPreviousTexture; ///< Previous rendered texture
- NativeImageSourceQueuePtr mTargetSurface; ///< The target surface
- std::unique_ptr< rlottie::Animation > mVectorRenderer; ///< The vector animation renderer
- UploadCompletedSignalType mUploadCompletedSignal; ///< Upload completed signal
- tbm_surface_queue_h mTbmQueue; ///< Tbm surface queue handle
- uint32_t mTotalFrameNumber; ///< The total frame number
- uint32_t mWidth; ///< The width of the surface
- uint32_t mHeight; ///< The height of the surface
- uint32_t mDefaultWidth; ///< The width of the surface
- uint32_t mDefaultHeight; ///< The height of the surface
- float mFrameRate; ///< The frame rate of the content
- bool mResourceReady; ///< Whether the resource is ready
- bool mShaderChanged; ///< Whether the shader is changed to support native image
- bool mResourceReadyTriggered;///< Whether the resource ready is triggered
+ using SurfacePair = std::pair<tbm_surface_h, rlottie::Surface>;
+
+ std::string mUrl; ///< The content file path
+ std::vector<SurfacePair> mBuffers; ///< EGL Image vector
+ mutable Dali::Mutex mMutex; ///< Mutex
+ Dali::Renderer mRenderer; ///< Renderer
+ Dali::Texture mTexture; ///< Texture
+ Dali::Texture mRenderedTexture; ///< Rendered Texture
+ Dali::Texture mPreviousTexture; ///< Previous rendered texture
+ NativeImageSourceQueuePtr mTargetSurface; ///< The target surface
+ std::unique_ptr<rlottie::Animation> mVectorRenderer; ///< The vector animation renderer
+ UploadCompletedSignalType mUploadCompletedSignal; ///< Upload completed signal
+ tbm_surface_queue_h mTbmQueue; ///< Tbm surface queue handle
+ uint32_t mTotalFrameNumber; ///< The total frame number
+ uint32_t mWidth; ///< The width of the surface
+ uint32_t mHeight; ///< The height of the surface
+ uint32_t mDefaultWidth; ///< The width of the surface
+ uint32_t mDefaultHeight; ///< The height of the surface
+ float mFrameRate; ///< The frame rate of the content
+ bool mLoadFailed; ///< Whether the file is loaded
+ bool mResourceReady; ///< Whether the resource is ready
+ bool mShaderChanged; ///< Whether the shader is changed to support native image
+ bool mResourceReadyTriggered; ///< Whether the resource ready is triggered
};
} // namespace Plugin
-} // namespace Dali;
+} // namespace Dali
#endif // DALI_TIZEN_VECTOR_ANIMATION_RENDERER_PLUGIN_H
projects / platform / core / uifw / dali-extension.git / commitdiff