/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/animation/time-period.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/radian.h>
-#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/animation/animation-playlist.h>
#include <dali/internal/event/animation/animator-connector.h>
+#include <dali/internal/event/animation/path-impl.h>
#include <dali/internal/event/common/notification-manager.h>
#include <dali/internal/event/common/property-helper.h>
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/effects/shader-effect-impl.h>
+#include <dali/internal/update/animation/scene-graph-animator.h>
#include <dali/internal/update/manager/update-manager.h>
using Dali::Internal::SceneGraph::UpdateManager;
}
Animation::Animation( EventThreadServices& eventThreadServices, AnimationPlaylist& playlist, float durationSeconds, EndAction endAction, EndAction disconnectAction, AlphaFunction defaultAlpha )
-: mEventThreadServices( eventThreadServices ),
+: mAnimation( NULL ),
+ mEventThreadServices( eventThreadServices ),
mPlaylist( playlist ),
- mAnimation( NULL ),
- mNotificationCount( 0 ),
- mFinishedCallback( NULL ),
- mFinishedCallbackObject( NULL ),
+ mFinishedSignal(),
+ mConnectors(),
+ mConnectorTargetValues(),
+ mPlayRange( Vector2(0.0f,1.0f)),
mDurationSeconds( durationSeconds ),
mSpeedFactor(1.0f),
+ mNotificationCount( 0 ),
mLoopCount(1),
mCurrentLoop(0),
- mPlayRange( Vector2(0.0f,1.0f)),
mEndAction( endAction ),
mDisconnectAction( disconnectAction ),
mDefaultAlpha( defaultAlpha ),
- mState(Dali::Animation::STOPPED)
+ mState(Dali::Animation::STOPPED),
+ mProgressReachedMarker( 0.0f ),
+ mDelaySeconds( 0.0f )
{
}
{
DALI_ASSERT_DEBUG( mAnimation == NULL );
- // Create a new animation, temporarily owned
- SceneGraph::Animation* animation = SceneGraph::Animation::New( mDurationSeconds, mSpeedFactor, mPlayRange, mLoopCount, mEndAction, mDisconnectAction );
-
- // Keep a const pointer to the animation.
- mAnimation = animation;
-
- // Transfer animation ownership to the update manager through a message
- AddAnimationMessage( mEventThreadServices.GetUpdateManager(), animation );
+ // Create a new animation, Keep a const pointer to the animation.
+ mAnimation = SceneGraph::Animation::New( mDurationSeconds, mSpeedFactor, mPlayRange, mLoopCount, mEndAction, mDisconnectAction );
+ OwnerPointer< SceneGraph::Animation > transferOwnership( const_cast< SceneGraph::Animation* >( mAnimation ) );
+ AddAnimationMessage( mEventThreadServices.GetUpdateManager(), transferOwnership );
}
void Animation::DestroySceneObject()
SetDurationMessage( mEventThreadServices, *mAnimation, seconds );
}
+void Animation::SetProgressNotification( float progress )
+{
+ // mAnimation is being used in a separate thread; queue a message to set the value
+ mProgressReachedMarker = progress;
+}
+
+float Animation::GetProgressNotification()
+{
+ return mProgressReachedMarker;
+}
+
float Animation::GetDuration() const
{
// This is not animatable; the cached value is up-to-date.
mState = Dali::Animation::PLAYING;
+ NotifyObjects();
+
+ SendFinalProgressNotificationMessage();
+
// mAnimation is being used in a separate thread; queue a Play message
PlayAnimationMessage( mEventThreadServices, *mAnimation );
}
mState = Dali::Animation::PLAYING;
+ NotifyObjects();
+
+ SendFinalProgressNotificationMessage();
+
// mAnimation is being used in a separate thread; queue a Play message
PlayAnimationFromMessage( mEventThreadServices, *mAnimation, progress );
}
}
+void Animation::PlayAfter( float delaySeconds )
+{
+ // The negative delay means play immediately.
+ delaySeconds = std::max( 0.f, delaySeconds );
+
+ mDelaySeconds = delaySeconds;
+
+ // Update the current playlist
+ mPlaylist.OnPlay( *this );
+
+ mState = Dali::Animation::PLAYING;
+
+ NotifyObjects();
+
+ SendFinalProgressNotificationMessage();
+
+ // mAnimation is being used in a separate thread; queue a message to set the value
+ PlayAfterMessage( mEventThreadServices, *mAnimation, delaySeconds );
+}
+
void Animation::Pause()
{
mState = Dali::Animation::PAUSED;
// Remove all the connectors
mConnectors.Clear();
+ // Reset the connector target values
+ mConnectorTargetValues.clear();
+
// Replace the old scene-object with a new one
DestroySceneObject();
CreateSceneObject();
void Animation::AnimateBy(Property& target, Property::Value& relativeValue, AlphaFunction alpha, TimePeriod period)
{
- Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
+ Object& object = GetImplementation(target.object);
+ const Property::Type targetType = object.GetPropertyType(target.propertyIndex);
+ const Property::Type destinationType = relativeValue.GetType();
- ExtendDuration( period );
+ if ( object.GetPropertyComponentIndex( target.propertyIndex ) != Property::INVALID_COMPONENT_INDEX )
+ {
+ DALI_ASSERT_ALWAYS(Property::FLOAT == destinationType && "Animated value and Property type don't match");
+ }
+ else
+ {
+ DALI_ASSERT_ALWAYS(targetType == destinationType && "Animated value and Property type don't match");
+ }
- switch ( relativeValue.GetType() )
+ ExtendDuration(period);
+
+ // Store data to later notify the object that its property is being animated
+ ConnectorTargetValues connectorPair;
+ connectorPair.targetValue = relativeValue;
+ connectorPair.connectorIndex = mConnectors.Count();
+ connectorPair.timePeriod = period;
+ connectorPair.animatorType = Animation::BY;
+ mConnectorTargetValues.push_back( connectorPair );
+
+ switch ( targetType )
{
case Property::BOOLEAN:
{
}
default:
- DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should never come here
- break;
+ {
+ // non animatable types handled already
+ }
}
}
void Animation::AnimateTo(Property& target, Property::Value& destinationValue, AlphaFunction alpha, TimePeriod period)
{
- Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
+ Object& object = GetImplementation(target.object);
AnimateTo( object, target.propertyIndex, target.componentIndex, destinationValue, alpha, period );
}
void Animation::AnimateTo(Object& targetObject, Property::Index targetPropertyIndex, int componentIndex, Property::Value& destinationValue, AlphaFunction alpha, TimePeriod period)
{
- Property::Type type = targetObject.GetPropertyType(targetPropertyIndex);
- if(componentIndex != Property::INVALID_COMPONENT_INDEX)
+ Property::Type targetType = targetObject.GetPropertyType(targetPropertyIndex);
+ if( componentIndex != Property::INVALID_COMPONENT_INDEX )
{
- if( type == Property::VECTOR2
- || type == Property::VECTOR3
- || type == Property::VECTOR4 )
+ if( ( targetType == Property::VECTOR2 ) ||
+ ( targetType == Property::VECTOR3 ) ||
+ ( targetType == Property::VECTOR4 ) )
{
- type = Property::FLOAT;
+ targetType = Property::FLOAT;
}
}
- DALI_ASSERT_ALWAYS( type == destinationValue.GetType() && "DestinationValue does not match Target Property type" );
+ const Property::Type destinationType = destinationValue.GetType();
+ DALI_ASSERT_ALWAYS( targetType == destinationType && "Animated value and Property type don't match" );
ExtendDuration( period );
- switch (destinationValue.GetType())
+ // Store data to later notify the object that its property is being animated
+ ConnectorTargetValues connectorPair;
+ connectorPair.targetValue = destinationValue;
+ connectorPair.connectorIndex = mConnectors.Count();
+ connectorPair.timePeriod = period;
+ connectorPair.animatorType = Animation::TO;
+ mConnectorTargetValues.push_back( connectorPair );
+
+ switch ( destinationType )
{
case Property::BOOLEAN:
{
case Property::FLOAT:
{
- if ( ( Dali::Actor::Property::SIZE_WIDTH == targetPropertyIndex ) ||
- ( Dali::Actor::Property::SIZE_HEIGHT == targetPropertyIndex ) ||
- ( Dali::Actor::Property::SIZE_DEPTH == targetPropertyIndex ) )
- {
- // Test whether this is actually an Actor
- Actor* maybeActor = dynamic_cast<Actor*>( &targetObject );
- if ( maybeActor )
- {
- // Notify the actor that its size is being animated
- maybeActor->NotifySizeAnimation( *this, destinationValue.Get<float>(), targetPropertyIndex );
- }
- }
- else if ( ( Dali::Actor::Property::POSITION_X == targetPropertyIndex ) ||
- ( Dali::Actor::Property::POSITION_Y == targetPropertyIndex ) ||
- ( Dali::Actor::Property::POSITION_Z == targetPropertyIndex ) )
- {
- // Test whether this is actually an Actor
- Actor* maybeActor = dynamic_cast<Actor*>( &targetObject );
- if ( maybeActor )
- {
- // Notify the actor that its position is being animated
- maybeActor->NotifyPositionAnimation( *this, destinationValue.Get<float>(), targetPropertyIndex );
- }
- }
-
AddAnimatorConnector( AnimatorConnector<float>::New( targetObject,
targetPropertyIndex,
componentIndex,
case Property::VECTOR3:
{
- if ( Dali::Actor::Property::SIZE == targetPropertyIndex )
- {
- // Test whether this is actually an Actor
- Actor* maybeActor = dynamic_cast<Actor*>( &targetObject );
- if ( maybeActor )
- {
- // Notify the actor that its size is being animated
- maybeActor->NotifySizeAnimation( *this, destinationValue.Get<Vector3>() );
- }
- }
- else if ( Dali::Actor::Property::POSITION == targetPropertyIndex )
- {
- // Test whether this is actually an Actor
- Actor* maybeActor = dynamic_cast<Actor*>( &targetObject );
- if ( maybeActor )
- {
- // Notify the actor that its position is being animated
- maybeActor->NotifyPositionAnimation( *this, destinationValue.Get<Vector3>() );
- }
- }
-
AddAnimatorConnector( AnimatorConnector<Vector3>::New( targetObject,
targetPropertyIndex,
componentIndex,
}
default:
- DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should never come here
- break;
+ {
+ // non animatable types handled already
+ }
}
}
void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, AlphaFunction alpha, TimePeriod period, Interpolation interpolation)
{
- Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
+ Object& object = GetImplementation( target.object );
ExtendDuration( period );
+ // Store data to later notify the object that its property is being animated
+ ConnectorTargetValues connectorPair;
+ connectorPair.targetValue = keyFrames.GetLastKeyFrameValue();
+ connectorPair.connectorIndex = mConnectors.Count();
+ connectorPair.timePeriod = period;
+ connectorPair.animatorType = BETWEEN;
+ mConnectorTargetValues.push_back( connectorPair );
+
switch(keyFrames.GetType())
{
case Dali::Property::BOOLEAN:
break;
}
- default: // not all property types are animateable
- break;
+ default:
+ {
+ // non animatable types handled by keyframes
+ }
}
}
return mFinishedSignal;
}
+Dali::Animation::AnimationSignalType& Animation::ProgressReachedSignal()
+{
+ return mProgressReachedSignal;
+}
+
void Animation::EmitSignalFinish()
{
if ( !mFinishedSignal.Empty() )
Dali::Animation handle( this );
mFinishedSignal.Emit( handle );
}
+}
- // This callback is used internally, to avoid the overhead of using a signal.
- if ( mFinishedCallback )
+void Animation::EmitSignalProgressReached()
+{
+ if ( !mProgressReachedSignal.Empty() )
{
- mFinishedCallback( mFinishedCallbackObject );
+ Dali::Animation handle( this );
+ mProgressReachedSignal.Emit( handle );
}
}
return connected;
}
-void Animation::SetFinishedCallback( FinishedCallback callback, Object* object )
-{
- mFinishedCallback = callback;
- mFinishedCallbackObject = object;
-}
-
void Animation::AddAnimatorConnector( AnimatorConnectorBase* connector )
{
DALI_ASSERT_DEBUG( NULL != connector );
return mPlayRange;
}
+bool Animation::CompareConnectorEndTimes( const Animation::ConnectorTargetValues& lhs, const Animation::ConnectorTargetValues& rhs )
+{
+ return ( ( lhs.timePeriod.delaySeconds + lhs.timePeriod.durationSeconds ) < ( rhs.timePeriod.delaySeconds + rhs.timePeriod.durationSeconds ) );
+}
+
+void Animation::NotifyObjects()
+{
+ if( mEndAction != EndAction::Discard ) // If the animation is discarded, then we do not want to change the target values
+ {
+ // Sort according to end time with earlier end times coming first, if the end time is the same, then the connectors are not moved
+ std::stable_sort( mConnectorTargetValues.begin(), mConnectorTargetValues.end(), CompareConnectorEndTimes );
+
+ // Loop through all connector target values sorted by increasing end time
+ ConnectorTargetValuesContainer::const_iterator iter = mConnectorTargetValues.begin();
+ const ConnectorTargetValuesContainer::const_iterator endIter = mConnectorTargetValues.end();
+ for( ; iter != endIter; ++iter )
+ {
+ AnimatorConnectorBase* connector = mConnectors[ iter->connectorIndex ];
+
+ Object* object = connector->GetObject();
+ if( object )
+ {
+ object->NotifyPropertyAnimation( *this, connector->GetPropertyIndex(), iter->targetValue, iter->animatorType );
+ }
+ }
+ }
+}
+
+
+void Animation::SendFinalProgressNotificationMessage()
+{
+ if ( mProgressReachedMarker > 0.0f )
+ {
+ float progressMarkerSeconds = mDurationSeconds * mProgressReachedMarker;
+ SetProgressNotificationMessage( mEventThreadServices, *mAnimation, progressMarkerSeconds );
+ }
+}
} // namespace Internal