Make SvgVisual use VectorImageRenderer which is using ThorVG.
You can use nanosvg or thorVG by NO_THORVG macro define.
[Note]
If you want to use THORVG, remove below from ./build/tizen/CMakeLists.txt
...
ADD_DEFINITIONS( "-DNO_THORVG" )
...
Change-Id: Ia9bf5c799084e841ff567245a8ff4688824277ee
../dali-toolkit/dali-toolkit-test-utils/toolkit-timer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-tts-player.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
+ ../dali-toolkit/dali-toolkit-test-utils/toolkit-vector-image-renderer.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-window.cpp
../dali-toolkit/dali-toolkit-test-utils/toolkit-scene-holder.cpp
../dali-toolkit/dali-toolkit-test-utils/dali-test-suite-utils.cpp
dali-toolkit-test-utils/toolkit-tts-player.cpp
dali-toolkit-test-utils/toolkit-native-image-source.cpp
dali-toolkit-test-utils/toolkit-vector-animation-renderer.cpp
+ dali-toolkit-test-utils/toolkit-vector-image-renderer.cpp
dali-toolkit-test-utils/toolkit-video-player.cpp
dali-toolkit-test-utils/toolkit-web-engine.cpp
dali-toolkit-test-utils/toolkit-window.cpp
--- /dev/null
+/*
+ * Copyright (c) 2020 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/devel-api/adaptor-framework/vector-image-renderer.h>
+#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/rendering/renderer.h>
+#include <toolkit-application.h>
+#include <toolkit-event-thread-callback.h>
+#include <memory>
+#include <sys/stat.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace Adaptor
+{
+
+class VectorImageRenderer: public Dali::BaseObject
+{
+public:
+
+ VectorImageRenderer()
+ : mUrl(),
+ mRenderer(),
+ mWidth( 0 ),
+ mHeight( 0 )
+ {
+ }
+
+ ~VectorImageRenderer()
+ {
+ }
+
+ bool Render( float scale )
+ {
+ return true;
+ }
+
+ void SetBuffer( Dali::Devel::PixelBuffer &buffer )
+ {
+ }
+
+ bool Load( const std::string& url )
+ {
+ struct stat sb;
+ if ( stat(url.c_str(), &sb) == 0 )
+ {
+ return true;
+ }
+
+ return false;
+ }
+
+ bool Load( const char *data, uint32_t size )
+ {
+ return true;
+ }
+
+ void GetDefaultSize( uint32_t& width, uint32_t& height ) const
+ {
+ width = 100;
+ height = 100;
+ }
+
+public:
+
+ std::string mUrl;
+ Dali::Renderer mRenderer;
+ uint32_t mWidth;
+ uint32_t mHeight;
+};
+
+inline VectorImageRenderer& GetImplementation( Dali::VectorImageRenderer& renderer )
+{
+ DALI_ASSERT_ALWAYS( renderer && "VectorImageRenderer handle is empty." );
+ BaseObject& handle = renderer.GetBaseObject();
+ return static_cast< Internal::Adaptor::VectorImageRenderer& >( handle );
+}
+
+inline const VectorImageRenderer& GetImplementation( const Dali::VectorImageRenderer& renderer )
+{
+ DALI_ASSERT_ALWAYS( renderer && "VectorImageRenderer handle is empty." );
+ const BaseObject& handle = renderer.GetBaseObject();
+ return static_cast< const Internal::Adaptor::VectorImageRenderer& >( handle );
+}
+
+} // namespace Adaptor
+
+} // namespace Internal
+
+
+/********************************************************************************/
+/********************************* PUBLIC CLASS *******************************/
+/********************************************************************************/
+
+VectorImageRenderer VectorImageRenderer::New()
+{
+ Internal::Adaptor::VectorImageRenderer* imageRenderer = new Internal::Adaptor::VectorImageRenderer();
+
+ return VectorImageRenderer( imageRenderer );
+}
+
+VectorImageRenderer::VectorImageRenderer()
+{
+}
+
+VectorImageRenderer::~VectorImageRenderer()
+{
+}
+
+VectorImageRenderer::VectorImageRenderer( Internal::Adaptor::VectorImageRenderer* internal )
+: BaseHandle( internal )
+{
+}
+
+void VectorImageRenderer::SetBuffer( Dali::Devel::PixelBuffer &buffer )
+{
+ Internal::Adaptor::GetImplementation( *this ).SetBuffer( buffer );
+}
+
+bool VectorImageRenderer::Render( float scale )
+{
+ return Internal::Adaptor::GetImplementation( *this ).Render( scale );
+}
+
+bool VectorImageRenderer::Load( const std::string& url )
+{
+ return Internal::Adaptor::GetImplementation( *this ).Load( url );
+}
+
+bool VectorImageRenderer::Load( const char *data, uint32_t size )
+{
+ return Internal::Adaptor::GetImplementation( *this ).Load( data, size );
+}
+
+void VectorImageRenderer::GetDefaultSize( uint32_t& width, uint32_t& height ) const
+{
+ Internal::Adaptor::GetImplementation( *this ).GetDefaultSize( width, height );
+}
+
+} // namespace Dali
ADD_DEFINITIONS("-DTRACE_ENABLED")
ENDIF()
+# Remove below when thorvg is ready
+ADD_DEFINITIONS( "-DNO_THORVG" )
+
# Set paths
SET( toolkit_images_dir ${ROOT_SRC_DIR}/dali-toolkit/styles/images-common )
SET( toolkit_sounds_dir ${ROOT_SRC_DIR}/dali-toolkit/sounds )
#include <dali/integration-api/debug.h>
// INTERNAL INCLUDES
+#ifdef NO_THORVG
#include <dali-toolkit/third-party/nanosvg/nanosvgrast.h>
+#endif /* NO_THORVG */
#include <dali-toolkit/internal/visuals/svg/svg-visual.h>
namespace Dali
const char * const UNITS("px");
}
+#ifdef NO_THORVG
RasterizingTask::RasterizingTask( SvgVisual* svgRenderer, NSVGimage* parsedSvg, const VisualUrl& url, float dpi, unsigned int width, unsigned int height)
: mSvgVisual( svgRenderer ),
mParsedSvg( parsedSvg ),
{
mRasterizer = nsvgCreateRasterizer();
}
+#else /* NO_THORVG */
+RasterizingTask::RasterizingTask( SvgVisual* svgRenderer, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height, bool loaded)
+: mSvgVisual( svgRenderer ),
+ mVectorRenderer( vectorRenderer ),
+ mUrl( url ),
+ mDpi( dpi ),
+ mWidth( width ),
+ mHeight( height ),
+ mLoaded( loaded )
+{
+
+}
+#endif /* NO_THORVG */
RasterizingTask::~RasterizingTask()
{
+#ifdef NO_THORVG
nsvgDeleteRasterizer( mRasterizer );
+#endif /* NO_THORVG */
}
void RasterizingTask::Load()
{
+#ifdef NO_THORVG
if( mParsedSvg != NULL)
{
return;
remoteBuffer.PushBack( '\0' );
mParsedSvg = nsvgParse( reinterpret_cast<char*>(remoteBuffer.begin()), UNITS, mDpi );
}
+#else /* NO_THORVG */
+ if( !mLoaded && !mUrl.IsLocalResource() )
+ {
+ Dali::Vector<uint8_t> remoteBuffer;
+
+ if( !Dali::FileLoader::DownloadFileSynchronously( mUrl.GetUrl(), remoteBuffer ))
+ {
+ DALI_LOG_ERROR("Failed to download file!\n");
+ return;
+ }
+
+ remoteBuffer.PushBack( '\0' );
+ char *data = reinterpret_cast<char*>(remoteBuffer.begin());
+ if ( !mVectorRenderer.Load( data, remoteBuffer.Size()))
+ {
+ DALI_LOG_ERROR( "Failed to load data!\n" );
+ return;
+ }
+
+ mLoaded = true;
+ }
+#endif /* NO_THORVG */
}
void RasterizingTask::Rasterize( )
{
+#ifdef NO_THORVG
if( mParsedSvg != NULL && mWidth > 0u && mHeight > 0u )
{
float scaleX = static_cast<float>( mWidth ) / mParsedSvg->width;
mPixelData = Dali::PixelData::New( buffer, bufferSize, mWidth, mHeight, Pixel::RGBA8888, Dali::PixelData::DELETE_ARRAY );
}
+#else /* NO_THORVG */
+ if ( mWidth <= 0u || mHeight <= 0u )
+ {
+ DALI_LOG_ERROR( "Size is zero!\n" );
+ return;
+ }
+
+ Devel::PixelBuffer pixelBuffer = Devel::PixelBuffer::New( mWidth, mHeight, Dali::Pixel::RGBA8888 );
+ mVectorRenderer.SetBuffer( pixelBuffer );
+ {
+ uint32_t defaultWidth, defaultHeight;
+ mVectorRenderer.GetDefaultSize( defaultWidth, defaultHeight );
+
+ float scaleX = static_cast<float>( mWidth ) / static_cast<float>( defaultWidth );
+ float scaleY = static_cast<float>( mHeight ) / static_cast<float>( defaultHeight );
+ float scale = scaleX < scaleY ? scaleX : scaleY;
+
+ if ( !mVectorRenderer.Render( scale ) )
+ {
+ DALI_LOG_ERROR( "SVG Render Fail!\n" );
+ return;
+ }
+
+ mPixelData = Devel::PixelBuffer::Convert( pixelBuffer );
+ if ( !mPixelData )
+ {
+ DALI_LOG_ERROR( "Pixel Data is null\n" );
+ }
+ }
+#endif /* NO_THORVG */
}
+#ifdef NO_THORVG
NSVGimage* RasterizingTask::GetParsedImage() const
{
return mParsedSvg;
}
+#else /* NO_THORVG */
+VectorImageRenderer RasterizingTask::GetVectorRenderer() const
+{
+ return mVectorRenderer;
+}
+
+bool RasterizingTask::IsLoaded() const
+{
+ return mLoaded;
+}
+#endif /* NO_THORVG */
SvgVisual* RasterizingTask::GetSvgVisual() const
{
}
}
+#ifdef NO_THORVG
void SvgRasterizeThread::DeleteImage( NSVGimage* parsedSvg )
{
// Lock while adding image to the delete queue
mDeleteSvg.PushBack( parsedSvg );
}
}
+#else /* NO_THORVG */
+void SvgRasterizeThread::DeleteImage( VectorImageRenderer vectorRenderer )
+{
+ // Lock while adding image to the delete queue
+ ConditionalWait::ScopedLock lock( mConditionalWait );
+
+ if( mIsThreadWaiting ) // no rasterization is ongoing, save to delete
+ {
+ // TODO: what?
+ }
+ else // wait to delete until current rasterization completed.
+ {
+ mDeleteSvg.PushBack( &vectorRenderer );
+ }
+}
+#endif /* NO_THORVG */
RasterizingTaskPtr SvgRasterizeThread::NextTaskToProcess()
{
// Delete the image here to make sure that it is not used in the nsvgRasterize()
if( !mDeleteSvg.Empty() )
{
+#ifdef NO_THORVG
for( Vector< NSVGimage* >::Iterator it = mDeleteSvg.Begin(), endIt = mDeleteSvg.End();
it != endIt;
++it )
{
nsvgDelete( *it );
}
+#endif /* NO_THORVG */
mDeleteSvg.Clear();
}
#include <dali/public-api/rendering/texture-set.h>
#include <dali-toolkit/internal/visuals/visual-url.h>
+#ifdef NO_THORVG
struct NSVGimage;
struct NSVGrasterizer;
+#else /* NO_THORVG */
+#include <string.h>
+#include <dali/devel-api/adaptor-framework/vector-image-renderer.h>
+#endif /* NO_THORVG */
namespace Dali
{
class RasterizingTask : public RefObject
{
public:
+#ifdef NO_THORVG
/**
* Constructor
*
* @param[in] height The rasterization height.
*/
RasterizingTask( SvgVisual* svgRenderer, NSVGimage* parsedSvg, const VisualUrl& url, float dpi, unsigned int width, unsigned int height );
+#else /* NO_THORVG */
+ /**
+ * Constructor
+ * @param[in] svgRenderer The renderer which the rasterized image to be applied.
+ * @param[in] url The URL to svg resource to use.
+ * @param[in] width The rasterization width.
+ * @param[in] height The rasterization height.
+ * @param[in] loaded The svg resource is loaded or not.
+ */
+ RasterizingTask( SvgVisual* svgRenderer, VectorImageRenderer vectorRenderer, const VisualUrl& url, float dpi, unsigned int width, unsigned int height, bool loaded );
+#endif /* NO_THORVG */
/**
* Destructor.
*/
PixelData GetPixelData() const;
+#ifdef NO_THORVG
/**
* Get the parsed data.
* @return parsed image data.
*/
NSVGimage* GetParsedImage() const;
+ /**
+ * Get default size of svg
+ *
+ * @param[out] width The default width of svg
+ * @param[out] height The default height of svg
+ */
+ void GetDefaultSize( uint32_t& width, uint32_t& height ) const;
+#else /* NO_THORVG */
+ /**
+ * Get the VectorRenderer.
+ * @return VectorRenderer.
+ */
+ VectorImageRenderer GetVectorRenderer() const;
+ /**
+ * Whether the resource is loaded.
+ * @return True if the resource is loaded.
+ */
+ bool IsLoaded() const;
+#endif /* NO_THORVG */
/**
* Load svg file
private:
SvgVisualPtr mSvgVisual;
+#ifdef NO_THORVG
NSVGimage* mParsedSvg;
+#else /* NO_THORVG */
+ VectorImageRenderer mVectorRenderer;
+#endif /* NO_THORVG */
VisualUrl mUrl;
PixelData mPixelData;
float mDpi;
unsigned int mWidth;
unsigned int mHeight;
+#ifdef NO_THORVG
NSVGrasterizer* mRasterizer;
+#else /* NO_THORVG */
+ bool mLoaded;
+#endif /* NO_THORVG */
};
/**
*/
void RemoveTask( SvgVisual* visual );
+#ifdef NO_THORVG
/**
* Delete the parsed SVG image, called by main thread.
*
- * The parsed svg should be delelted in worker thread, as the main thread does not know whether a rasterization of this svg is ongoing.
+ * The parsed svg should be deleted in worker thread, as the main thread does not know whether a rasterization of this svg is ongoing.
*
* @param[in] parsedImage The image to be deleted
*/
void DeleteImage( NSVGimage* parsedSvg );
+#else /* NO_THORVG */
+ /**
+ * Delete the parsed SVG image, called by main thread.
+ *
+ * The parsed svg should be deleted in worker thread, as the main thread does not know whether a rasterization of this svg is ongoing.
+ *
+ * @param[in] VectorImage The image to be deleted
+ */
+ void DeleteImage( VectorImageRenderer vectorImage );
+#endif /* NO_THORVG */
private:
std::vector<RasterizingTaskPtr> mRasterizeTasks; //The queue of the tasks waiting to rasterize the SVG image
std::vector <RasterizingTaskPtr> mCompletedTasks; //The queue of the tasks with the SVG rasterization completed
+#ifdef NO_THORVG
Vector<NSVGimage*> mDeleteSvg; //The images that the event thread requested to delete
+#else /* NO_THORVG */
+ Vector <VectorImageRenderer*> mDeleteSvg; //The images that the event thread requested to delete
+#endif /* NO_THORVG */
ConditionalWait mConditionalWait;
Dali::Mutex mMutex;
#include "svg-visual.h"
// INTERNAL INCLUDES
+#ifdef NO_THORVG
#include <dali-toolkit/third-party/nanosvg/nanosvg.h>
#include <dali-toolkit/third-party/nanosvg/nanosvgrast.h>
+#endif /* NO_THORVG */
#include <dali-toolkit/internal/visuals/svg/svg-rasterize-thread.h>
#include <dali-toolkit/internal/visuals/image-atlas-manager.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
{
SvgVisualPtr svgVisual( new SvgVisual( factoryCache, shaderFactory, imageUrl ) );
+#ifdef NO_THORVG
svgVisual->ParseFromUrl( imageUrl );
svgVisual->SetProperties( properties );
+#else /* NO_THORVG */
+ svgVisual->Load();
+ svgVisual->SetProperties( properties );
+#endif /* NO_THORVG */
return svgVisual;
}
SvgVisualPtr SvgVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
{
SvgVisualPtr svgVisual( new SvgVisual( factoryCache, shaderFactory, imageUrl ) );
+#ifdef NO_THORVG
svgVisual->ParseFromUrl( imageUrl );
+#else /* NO_THORVG */
+ svgVisual->Load();
+#endif /* NO_THORVG */
return svgVisual;
}
mImageVisualShaderFactory( shaderFactory ),
mAtlasRect( FULL_TEXTURE_RECT ),
mImageUrl( imageUrl ),
+#ifdef NO_THORVG
mParsedImage( NULL ),
+#else
+ mVectorRenderer( VectorImageRenderer::New() ),
+ mDefaultWidth( 0 ),
+ mDefaultHeight( 0 ),
+ mLoaded( false ),
+ mLocalResource( true ),
+#endif /* NO_THORVG */
mPlacementActor(),
mVisualSize(Vector2::ZERO),
mAttemptAtlasing( false )
SvgVisual::~SvgVisual()
{
+#ifdef NO_THORVG
if( mParsedImage )
{
nsvgDelete( mParsedImage );
}
+#endif /* NO_THORVG */
}
void SvgVisual::DoSetProperties( const Property::Map& propertyMap )
void SvgVisual::GetNaturalSize( Vector2& naturalSize )
{
+#ifdef NO_THORVG
if( mParsedImage )
{
naturalSize.x = mParsedImage->width;
naturalSize.y = mParsedImage->height;
}
+#else /* NO_THORVG */
+ if ( mLoaded )
+ {
+ naturalSize.x = mDefaultWidth;
+ naturalSize.y = mDefaultHeight;
+ }
+#endif /* NO_THORVG */
else
{
naturalSize = Vector2::ZERO;
// Do nothing
}
+#ifdef NO_THORVG
void SvgVisual::ParseFromUrl( const VisualUrl& imageUrl )
{
mImageUrl = imageUrl;
}
}
}
+#else /* NO_THORVG */
+void SvgVisual::Load()
+{
+ if( mLoaded || !mLocalResource )
+ {
+ return;
+ }
+
+ mLocalResource = mImageUrl.IsLocalResource();
+
+ if( !mLocalResource )
+ {
+ // load remote resource on svg rasterize thread.
+ return;
+ }
+
+ if( !mVectorRenderer.Load( mImageUrl.GetUrl() ) )
+ {
+ DALI_LOG_ERROR( "Failed to load file!\n" );
+ return;
+ }
+
+ mVectorRenderer.GetDefaultSize(mDefaultWidth, mDefaultHeight);
+ mLoaded = true;
+}
+#endif /* NO_THORVG */
+
void SvgVisual::AddRasterizationTask( const Vector2& size )
{
Vector2 dpi = Stage::GetCurrent().GetDpi();
float meanDpi = ( dpi.height + dpi.width ) * 0.5f;
+#ifdef NO_THORVG
RasterizingTaskPtr newTask = new RasterizingTask( this, mParsedImage, mImageUrl, meanDpi, width, height );
+#else /* NO_THORVG */
+ RasterizingTaskPtr newTask = new RasterizingTask( this, mVectorRenderer, mImageUrl, meanDpi, width, height, mLoaded );
+#endif /* NO_THORVG */
if ( IsSynchronousLoadingRequired() )
{
+#ifdef NO_THORVG
newTask->Rasterize();
ApplyRasterizedImage( newTask->GetParsedImage(), newTask->GetPixelData() );
+#else /* NO_THORVG */
+ newTask->Load();
+ newTask->Rasterize();
+ ApplyRasterizedImage( newTask->GetVectorRenderer(), newTask->GetPixelData(), newTask->IsLoaded() );
+#endif /* NO_THORVG */
}
else
{
}
}
+#ifdef NO_THORVG
void SvgVisual::ApplyRasterizedImage( NSVGimage* parsedSvg, PixelData rasterizedPixelData )
{
if( mParsedImage == NULL)
}
if( mParsedImage && IsOnScene() )
+#else /* NO_THORVG */
+void SvgVisual::ApplyRasterizedImage( VectorImageRenderer vectorRenderer, PixelData rasterizedPixelData, bool isLoaded )
+{
+ mLoaded = isLoaded;
+
+ if( isLoaded && rasterizedPixelData && IsOnScene() )
+#endif /* NO_THORVG */
{
TextureSet currentTextureSet = mImpl->mRenderer.GetTextures();
if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED )
// Svg loaded and ready to display
ResourceReady( Toolkit::Visual::ResourceStatus::READY );
}
+#ifdef NO_THORVG
else if( !mParsedImage )
+#else /* NO_THORVG */
+ else if( !isLoaded || !rasterizedPixelData )
+#endif /* NO_THORVG */
{
ResourceReady( Toolkit::Visual::ResourceStatus::FAILED );
}
#include <dali-toolkit/internal/visuals/visual-base-impl.h>
#include <dali-toolkit/internal/visuals/visual-url.h>
+#ifdef NO_THORVG
struct NSVGimage;
+#endif /* NO_THORVG */
namespace Dali
{
public:
+#ifdef NO_THORVG
/**
* @bried Apply the rasterized image to the visual.
*
* @param[in] rasterizedPixelData The pixel buffer with the rasterized pixels
*/
void ApplyRasterizedImage( NSVGimage* parsedSvg, PixelData rasterizedPixelData );
+#else /* NO_THORVG */
+ /**
+ * @bried Apply the rasterized image to the visual.
+ *
+ * @param[in] vectorImage The data of vector image.
+ * @param[in] rasterizedPixelData The pixel buffer with the rasterized pixels
+ * @param[in] bool Whether the resource is loaded
+ */
+ void ApplyRasterizedImage( VectorImageRenderer vectorImage, PixelData rasterizedPixelData, bool isLoaded );
+#endif /* NO_THORVG */
private:
+#ifdef NO_THORVG
/**
* @brief Parses the SVG Image from the set URL.
*
* @param[in] imageUrl The URL of the image to parse the SVG from.
*/
void ParseFromUrl( const VisualUrl& imageUrl );
+#else /* NO_THORVG */
+ /**
+ * @brief Load the SVG Image from the set URL.
+ */
+ void Load();
+#endif /* NO_THORVG */
/**
* @bried Rasterize the svg with the given size, and add it to the visual.
ImageVisualShaderFactory& mImageVisualShaderFactory;
Vector4 mAtlasRect;
VisualUrl mImageUrl;
+#ifdef NO_THORVG
NSVGimage* mParsedImage;
+#else /* NO_THORVG */
+ VectorImageRenderer mVectorRenderer;
+ uint32_t mDefaultWidth;
+ uint32_t mDefaultHeight;
+ bool mLoaded;
+ bool mLocalResource;
+#endif /* NO_THORVG */
WeakHandle<Actor> mPlacementActor;
Vector2 mVisualSize;
bool mAttemptAtlasing; ///< If true will attempt atlasing, otherwise create unique texture
{
while( RasterizingTaskPtr task = mSvgRasterizeThread->NextCompletedTask() )
{
+#ifdef NO_THORVG
task->GetSvgVisual()->ApplyRasterizedImage( task->GetParsedImage(), task->GetPixelData() );
+#else /* NO_THORVG */
+ task->GetSvgVisual()->ApplyRasterizedImage( task->GetVectorRenderer(), task->GetPixelData(), task->IsLoaded() );
+#endif /* NO_THORVG */
}
}