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/common/stage-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/internal/visuals/image-visual-shader-factory.h>
  30 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  31 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
  32 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
  33 #include <dali-toolkit/internal/visuals/animated-vector-image/vector-image-rasterize-thread.h>
  34 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.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 ),
  69   mImageVisualShaderFactory( shaderFactory ),
  70   mUrl( imageUrl ),
  71   mVisualSize(),
  72   mPlacementActor(),
  73   mVectorRasterizeThread(),
  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
  80 AnimatedVectorImageVisual::~AnimatedVectorImageVisual()
  81 {
  82 }
  83
  84 void AnimatedVectorImageVisual::GetNaturalSize( Vector2& naturalSize )
  85 {
  86   naturalSize = mVisualSize;
  87 }
  88
  89 void AnimatedVectorImageVisual::DoCreatePropertyMap( Property::Map& map ) const
  90 {
  91   map.Clear();
  92   map.Insert( Toolkit::Visual::Property::TYPE, Toolkit::DevelVisual::ANIMATED_VECTOR_IMAGE );
  93   if( mUrl.IsValid() )
  94   {
  95     map.Insert( Toolkit::ImageVisual::Property::URL, mUrl.GetUrl() );
  96   }
  97 }
  98
  99 void AnimatedVectorImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
 100 {
 101   // Do nothing
 102 }
 103
 104 void AnimatedVectorImageVisual::DoSetProperties( const Property::Map& propertyMap )
 105 {
 106   // url already passed in from constructor
 107   for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
 108   {
 109     KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
 110     if( keyValue.first.type == Property::Key::INDEX )
 111     {
 112       DoSetProperty( keyValue.first.indexKey, keyValue.second );
 113     }
 114   }
 115 }
 116
 117 void AnimatedVectorImageVisual::DoSetProperty( Property::Index index, const Property::Value& value )
 118 {
 119 }
 120
 121 void AnimatedVectorImageVisual::DoSetOnStage( Actor& actor )
 122 {
 123   Shader shader;
 124
 125   if( mImpl->mCustomShader )
 126   {
 127     shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
 128                           mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
 129                           mImpl->mCustomShader->mHints );
 130
 131     shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
 132   }
 133   else
 134   {
 135     shader = mImageVisualShaderFactory.GetShader( mFactoryCache, false, true );
 136   }
 137
 138   Geometry geometry = mFactoryCache.GetGeometry( VisualFactoryCache::QUAD_GEOMETRY );
 139
 140   mImpl->mRenderer = Renderer::New( geometry, shader );
 141
 142   TextureSet textureSet = TextureSet::New();
 143   mImpl->mRenderer.SetTextures( textureSet );
 144
 145   // Register transform properties
 146   mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
 147
 148   // Defer the rasterisation task until we get given a size (by Size Negotiation algorithm)
 149
 150   // Hold the weak handle of the placement actor and delay the adding of renderer until the rasterization is finished.
 151   mPlacementActor = actor;
 152
 153   // This visual needs it's size set before it can be rasterized hence set ResourceReady once on stage
 154   ResourceReady( Toolkit::Visual::ResourceStatus::READY );
 155 }
 156
 157 void AnimatedVectorImageVisual::DoSetOffStage( Actor& actor )
 158 {
 159   if( mVectorRasterizeThread )
 160   {
 161     mVectorRasterizeThread->PauseAnimation();
 162     DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
 163     mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 164   }
 165
 166   if( mImpl->mRenderer )
 167   {
 168     actor.RemoveRenderer( mImpl->mRenderer );
 169     mImpl->mRenderer.Reset();
 170   }
 171
 172   mPlacementActor.Reset();
 173
 174   // Reset the visual size to zero so that when adding the actor back to stage the rasterization is forced
 175   mVisualSize = Vector2::ZERO;
 176 }
 177
 178 void AnimatedVectorImageVisual::OnSetTransform()
 179 {
 180   Vector2 visualSize = mImpl->mTransform.GetVisualSize( mImpl->mControlSize );
 181
 182   if( IsOnStage() )
 183   {
 184     if( visualSize != mVisualSize )
 185     {
 186       mVisualSize = visualSize;
 187
 188       if( !mVectorRasterizeThread )
 189       {
 190         uint32_t width = static_cast< uint32_t >( visualSize.width );
 191         uint32_t height = static_cast< uint32_t >( visualSize.height );
 192
 193         mVectorRasterizeThread = std::unique_ptr< VectorRasterizeThread >( new VectorRasterizeThread( mUrl.GetUrl(), mImpl->mRenderer, width, height ) );
 194
 195         mVectorRasterizeThread->SetResourceReadyCallback( new EventThreadCallback( MakeCallback( this, &AnimatedVectorImageVisual::OnResourceReady ) ) );
 196         mVectorRasterizeThread->Start();
 197
 198         if( mActionStatus == DevelAnimatedVectorImageVisual::Action::PLAY )
 199         {
 200           mVectorRasterizeThread->StartAnimation();
 201           DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY );
 202         }
 203         else
 204         {
 205           // Render one frame
 206           mVectorRasterizeThread->RenderFrame();
 207         }
 208       }
 209       else
 210       {
 211         // TODO: change size
 212       }
 213     }
 214   }
 215 }
 216
 217 void AnimatedVectorImageVisual::OnDoAction( const Property::Index actionId, const Property::Value& attributes )
 218 {
 219   if( actionId == mActionStatus )
 220   {
 221     return;
 222   }
 223
 224   // Check if action is valid for this visual type and perform action if possible
 225   switch( actionId )
 226   {
 227     case DevelAnimatedVectorImageVisual::Action::PLAY:
 228     {
 229       if( IsOnStage())
 230       {
 231         if( mVectorRasterizeThread )
 232         {
 233           mVectorRasterizeThread->StartAnimation();
 234           DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY );   //TODO: Should manage this globally
 235         }
 236       }
 237       mActionStatus = DevelAnimatedVectorImageVisual::Action::PLAY;
 238       break;
 239     }
 240     case DevelAnimatedVectorImageVisual::Action::PAUSE:
 241     {
 242       if( mVectorRasterizeThread )
 243       {
 244         mVectorRasterizeThread->PauseAnimation();
 245         DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
 246       }
 247       mActionStatus = DevelAnimatedVectorImageVisual::Action::PAUSE;
 248       break;
 249     }
 250     case DevelAnimatedVectorImageVisual::Action::RESUME:
 251     {
 252       if( mVectorRasterizeThread )
 253       {
 254         mVectorRasterizeThread->ResumeAnimation();
 255         DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::CONTINUOUSLY );
 256       }
 257       mActionStatus = DevelAnimatedVectorImageVisual::Action::RESUME;
 258       break;
 259     }
 260     case DevelAnimatedVectorImageVisual::Action::STOP:
 261     {
 262       if( mVectorRasterizeThread )
 263       {
 264         mVectorRasterizeThread->StopAnimation();
 265         DevelStage::SetRenderingBehavior( Stage::GetCurrent(), DevelStage::Rendering::IF_REQUIRED );
 266       }
 267       mActionStatus = DevelAnimatedVectorImageVisual::Action::STOP;
 268       break;
 269     }
 270   }
 271 }
 272
 273 void AnimatedVectorImageVisual::OnResourceReady()
 274 {
 275   // If weak handle is holding a placement actor, it is the time to add the renderer to actor.
 276   Actor actor = mPlacementActor.GetHandle();
 277   if( actor )
 278   {
 279     actor.AddRenderer( mImpl->mRenderer );
 280     // reset the weak handle so that the renderer only get added to actor once
 281     mPlacementActor.Reset();
 282
 283     Stage::GetCurrent().KeepRendering( 0.0f );
 284   }
 285 }
 286
 287 } // namespace Internal
 288
 289 } // namespace Toolkit
 290
 291 } // namespace Dali