dali-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.cpp

   1 /*
   2  * Copyright (c) 2018 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-toolkit/internal/visuals/animated-vector-image/animated-vector-image-visual.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/common/stage.h>
  23 #include <dali/devel-api/rendering/renderer-devel.h>
  24 #include <dali/integration-api/debug.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
  28 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  29 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  30 #include <dali-toolkit/devel-api/visuals/animated-vector-image-visual-signals-devel.h>
  31 #include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
  32 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  33 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  34 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  35
  36 namespace Dali
  37 {
  38
  39 namespace Toolkit
  40 {
  41
  42 namespace Internal
  43 {
  44
  45 namespace
  46 {
  47
  48 const Dali::Vector4 FULL_TEXTURE_RECT( 0.f, 0.f, 1.f, 1.f );
  49
  50 } // unnamed namespace
  51
  52 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl, const Property::Map& properties )
  53 {
  54   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  55   visual->SetProperties( properties );
  56
  57   return visual;
  58 }
  59
  60 AnimatedVectorImageVisualPtr AnimatedVectorImageVisual::New( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  61 {
  62   AnimatedVectorImageVisualPtr visual( new AnimatedVectorImageVisual( factoryCache, shaderFactory, imageUrl ) );
  63
  64   return visual;
  65 }
  66
  67 AnimatedVectorImageVisual::AnimatedVectorImageVisual( VisualFactoryCache& factoryCache, ImageVisualShaderFactory& shaderFactory, const VisualUrl& imageUrl )
  68 : Visual::Base( factoryCache, Visual::FittingMode::FILL ),
  69   mImageVisualShaderFactory( shaderFactory ),
  70   mUrl( imageUrl ),
  71   mVectorRasterizeThread( imageUrl.GetUrl() ),
  72   mVisualSize(),
  73   mPlacementActor(),
  74   mActionStatus( DevelAnimatedVectorImageVisual::Action::STOP )
  75 {
  76   // the rasterized image is with pre-multiplied alpha format
  77   mImpl->mFlags |= Impl::IS_PREMULTIPLIED_ALPHA;
  78
  79   mVectorRasterizeThread.SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
  80   mVectorRasterizeThread.SetAnimationFinishedCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnAnimationFinished ) ) );
  81
  82   mVectorRasterizeThread.Start();
  83 }
  84
  85 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
  86 {
  87 }
  88
  89 void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize )
  90 {
  91   naturalSize = mVisualSize;
  92 }
  93
  94 void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
  95 {
  96   map.Clear();
  97   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE );
  98   if( mUrl.IsValid() )
  99   {
 100     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
 101   }
 102   map.Insert( Toolkit::DevelImageVisual::Property::LOOP_COUNT, static_cast< int >( mVectorRasterizeThread.GetLoopCount() ) );
 103   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_RANGE, static_cast< Vector2 >( mVectorRasterizeThread.GetPlayRange() ) );
 104   map.Insert( Toolkit::DevelImageVisual::Property::PLAY_STATE, static_cast< int >( mVectorRasterizeThread.GetPlayState() ) );
 105 }
 106
 107 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 108 {
 109   // Do nothing
 110 }
 111
 112 void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMap )
 113 {
 114   // url already passed in from constructor
 115   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 116   {
 117     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 118     if( keyValue.first.type == Property::Key::INDEX )
 119     {
 120       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 121     }
 122     else
 123     {
 124        if( keyValue.first == LOOP_COUNT_NAME )
 125        {
 126           DoSetProperty( Toolkit::DevelImageVisual::Property::LOOP_COUNT, keyValue.second );
 127        }
 128        else if( keyValue.first == PLAY_RANGE_NAME )
 129        {
 130           DoSetProperty( Toolkit::DevelImageVisual::Property::PLAY_RANGE, keyValue.second );
 131        }
 132     }
 133   }
 134 }
 135
 136 void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 137 {
 138   switch(index)
 139   {
 140     case Toolkit::DevelImageVisual::Property::LOOP_COUNT:
 141     {
 142       int32_t loopCount;
 143       if( value.Get( loopCount ) )
 144       {
 145         mVectorRasterizeThread.SetLoopCount( loopCount );
 146       }
 147       break;
 148     }
 149     case Toolkit::DevelImageVisual::Property::PLAY_RANGE:
 150     {
 151       Vector2 range;
 152       if( value.Get( range ) )
 153       {
 154         mVectorRasterizeThread.SetPlayRange( range );
 155       }
 156       break;
 157     }
 158   }
 159 }
 160
 161 void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
 162 {
 163   Shader shader;
 164
 165   if( mImpl->mCustomShader )
 166   {
 167     shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
 168                           mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
 169                           mImpl->mCustomShader->mHints );
 170
 171     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 172   }
 173   else
 174   {
 175     shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
 176   }
 177
 178   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 179
 180   mImpl->mRenderer = Renderer::New( geometry, shader );
 181
 182   TextureSet textureSet = TextureSet::New();
 183   mImpl->mRenderer.SetTextures( textureSet );
 184
 185   // Register transform properties
 186   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 187
 188   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 189
 190   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 191   mPlacementActor = actor;
 192
 193   mVectorRasterizeThread.SetRenderer( mImpl->mRenderer );
 194 }
 195
 196 void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor )
 197 {
 198   mVectorRasterizeThread.PauseAnimation();
 199
 200   mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 201
 202   if( mImpl->mRenderer )
 203   {
 204     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 205
 206     actor.RemoveRenderer( mImpl->mRenderer );
 207     mImpl->mRenderer.Reset();
 208   }
 209
 210   mPlacementActor.Reset();
 211
 212   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 213   mVisualSize = Vector2::ZERO;
 214 }
 215
 216 void AnimatedVectorImageVisual::OnSetTransform()
 217 {
 218   Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize );
 219
 220   if( IsOnStage() )
 221   {
 222     if( visualSize != mVisualSize )
 223     {
 224       mVisualSize = visualSize;
 225
 226       uint32_t width = static_cast< uint32_t >( visualSize.width );
 227       uint32_t height = static_cast< uint32_t >( visualSize.height );
 228
 229       mVectorRasterizeThread.SetSize( width, height );
 230     }
 231
 232     if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
 233     {
 234       mVectorRasterizeThread.PlayAnimation();
 235
 236       mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 237     }
 238     else
 239     {
 240       // Render one frame
 241       mVectorRasterizeThread.RenderFrame();
 242     }
 243
 244     if( mVectorRasterizeThread.IsResourceReady() )
 245     {
 246       Actor actor = mPlacementActor.GetHandle();
 247       if( actor )
 248       {
 249         actor.AddRenderer( mImpl->mRenderer );
 250         mPlacementActor.Reset();
 251       }
 252
 253       ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 254     }
 255   }
 256 }
 257
 258 void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 259 {
 260   // Check if action is valid for this visual type and perform action if possible
 261   switch( actionId )
 262   {
 263     case DevelAnimatedVectorImageVisual::Action::PLAY:
 264     {
 265       if( IsOnStage() )
 266       {
 267         mVectorRasterizeThread.PlayAnimation();
 268
 269         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
 270       }
 271       mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY;
 272       break;
 273     }
 274     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 275     {
 276       mVectorRasterizeThread.PauseAnimation();
 277
 278       if( mImpl->mRenderer )
 279       {
 280         mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 281       }
 282
 283       mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 284       break;
 285     }
 286     case DevelAnimatedVectorImageVisual::Action::STOP:
 287     {
 288       if( mVectorRasterizeThread.GetPlayState() != DevelImageVisual::PlayState::STOPPED )
 289       {
 290         mVectorRasterizeThread.StopAnimation();
 291
 292         OnAnimationFinished();
 293       }
 294       mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 295       break;
 296     }
 297   }
 298 }
 299
 300 void AnimatedVectorImageVisual::OnResourceReady()
 301 {
 302   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 303   Actor actor = mPlacementActor.GetHandle();
 304   if( actor )
 305   {
 306     actor.AddRenderer( mImpl->mRenderer );
 307     // reset the weak handle so that the renderer only get added to actor once
 308     mPlacementActor.Reset();
 309   }
 310
 311   ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 312 }
 313
 314 void AnimatedVectorImageVisual::OnAnimationFinished()
 315 {
 316   if( mImpl->mEventObserver )
 317   {
 318     mImpl->mEventObserver->NotifyVisualEvent( *this, DevelAnimatedVectorImageVisual::Signal::ANIMATION_FINISHED );
 319   }
 320
 321   mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 322
 323   if( mImpl->mRenderer )
 324   {
 325     mImpl->mRenderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
 326   }
 327 }
 328
 329 } // namespace Internal
 330
 331 } // namespace Toolkit
 332
 333 } // namespace Dali