X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftransition-effects%2Fcube-transition-effect-impl.cpp;h=31dd1577a282948ef4fe905ff2bfef54c5706e73;hb=refs%2Fchanges%2F46%2F265846%2F1;hp=2872ffa0e9101e01f7fc62335c7acb2c988234f3;hpb=826a077bb3183b5d317bfb22e14ab4e217d26f40;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp index 2872ffa..31dd157 100644 --- a/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp +++ b/dali-toolkit/internal/transition-effects/cube-transition-effect-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 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. @@ -19,51 +19,52 @@ #include "cube-transition-effect-impl.h" // EXTERNAL INCLUDES -#include -#include -#include +#include #include -#include +#include +#include // for strcmp + +// INTERNAL INCLUDES +#include +#include +#include namespace Dali { - namespace Toolkit { - namespace Internal { - namespace { - // Setup properties, signals and actions using the type-registry. -DALI_TYPE_REGISTRATION_BEGIN( Toolkit::CubeTransitionEffect, Dali::BaseHandle, NULL ); +DALI_TYPE_REGISTRATION_BEGIN(Toolkit::CubeTransitionEffect, Dali::BaseHandle, NULL); -DALI_SIGNAL_REGISTRATION( CubeTransitionEffect, "transition-completed", SIGNAL_TRANSITION_COMPLETED ) +DALI_SIGNAL_REGISTRATION(Toolkit, CubeTransitionEffect, "transitionCompleted", SIGNAL_TRANSITION_COMPLETED) DALI_TYPE_REGISTRATION_END() +Actor CreateTile(const Vector4& samplerRect) +{ + Actor tile = Actor::New(); + tile.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + tile.RegisterProperty("uTextureRect", samplerRect); + return tile; } -const Vector4 CubeTransitionEffect::FULL_BRIGHTNESS( 1.0f, 1.0f, 1.0f, 1.0f ); -const Vector4 CubeTransitionEffect::HALF_BRIGHTNESS( 0.5f, 0.5f, 0.5f, 1.0f ); - -CubeTransitionEffect::CubeTransitionEffect( unsigned int numRows, unsigned int numColumns, Size viewAreaSize ) -: mNumRows( numRows ), - mNumColumns( numColumns ), - mViewAreaSize( viewAreaSize ), - mRotateIndex( 0 ), - mContainerIndex( 0 ), - mChangeTurningDirection( false ), - mIsToNextImage( true ), - mIsImageLoading( false ), - mAnimationDuration( 1.f ), - mIsAnimating( false ), - mIsPaused( false ), - mCubeDisplacement( 0.f ), - mFirstTransition( true ), - mBufferIndex( 0 ) +} // namespace + +const Vector4 CubeTransitionEffect::FULL_BRIGHTNESS(1.0f, 1.0f, 1.0f, 1.0f); +const Vector4 CubeTransitionEffect::HALF_BRIGHTNESS(0.5f, 0.5f, 0.5f, 1.0f); + +CubeTransitionEffect::CubeTransitionEffect(unsigned int rows, unsigned int columns) +: Control(ControlBehaviour(DISABLE_STYLE_CHANGE_SIGNALS)), + mRows(rows), + mColumns(columns), + mIsAnimating(false), + mIsPaused(false), + mAnimationDuration(1.f), + mCubeDisplacement(0.f) { } @@ -71,96 +72,199 @@ CubeTransitionEffect::~CubeTransitionEffect() { } -void CubeTransitionEffect::Initialize() +void CubeTransitionEffect::SetTargetRight(unsigned int idx) +{ + mBoxType[idx] = RIGHT; + + mBoxes[idx].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f); + + mTargetTiles[idx].SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(1.f, 0.5f, 0.5f)); + mTargetTiles[idx].SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.f), Vector3::YAXIS)); +} + +void CubeTransitionEffect::SetTargetLeft(unsigned int idx) { - //create root actor for the cube transition effect, only visible during the transition - mRoot = Actor::New(); - mRoot.SetParentOrigin( ParentOrigin::CENTER ); - mRoot.SetAnchorPoint( AnchorPoint::CENTER ); - mRoot.SetVisible(false); - - // create two groups of tiles, - // and one group of actors (cubes) serving as parents of every two tiles (one from each image). - unsigned int totalNum = mNumColumns* mNumRows; - mBoxes.resize( totalNum ); - mTiles[0].resize( totalNum ); - mTiles[1].resize( totalNum ); - mTileSize = Vector2( mViewAreaSize.width / mNumColumns, mViewAreaSize.height / mNumRows ); - const Vector3 basePosition( (-mViewAreaSize.width + mTileSize.width) * 0.5f, - (-mViewAreaSize.height + mTileSize.height) * 0.5f, - -mTileSize.width * 0.5f ); - - Image placeHolder = BufferImage::WHITE(); - for( unsigned int y = 0; y < mNumRows; y++ ) + mBoxType[idx] = LEFT; + + mBoxes[idx].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f); + + mTargetTiles[idx].SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.f, 0.5f, 0.5f)); + mTargetTiles[idx].SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(-90.f), Vector3::YAXIS)); +} + +void CubeTransitionEffect::SetTargetBottom(unsigned int idx) +{ + mBoxType[idx] = BOTTOM; + + mBoxes[idx].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f); + + mTargetTiles[idx].SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 0.f, 0.5f)); + mTargetTiles[idx].SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.f), Vector3::XAXIS)); +} + +void CubeTransitionEffect::SetTargetTop(unsigned int idx) +{ + mBoxType[idx] = TOP; + + mBoxes[idx].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f); + + mTargetTiles[idx].SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 1.f, 0.5f)); + mTargetTiles[idx].SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(-90.f), Vector3::XAXIS)); +} + +void CubeTransitionEffect::OnRelayout(const Vector2& size, RelayoutContainer& container) +{ + mTileSize = Vector2(size.x / mColumns, size.y / mRows); + + mBoxRoot.SetProperty(Actor::Property::SIZE_WIDTH, size.x); + mBoxRoot.SetProperty(Actor::Property::SIZE_HEIGHT, size.y); + mBoxRoot.SetProperty(Actor::Property::SIZE_DEPTH, 1.0f); + + for(size_t i = 0; i < mBoxes.size(); ++i) { - float positionY = y * mTileSize.height + basePosition.y; - for( unsigned int x = 0; x < mNumColumns; x++) + mBoxes[i].SetProperty(Actor::Property::SIZE_WIDTH, mTileSize.x); + mBoxes[i].SetProperty(Actor::Property::SIZE_HEIGHT, mTileSize.y); + + switch(mBoxType[i]) { - unsigned int idx = y*mNumColumns + x; - Actor actor( Actor::New() ); - mBoxes[idx] = actor; - actor.SetParentOrigin( ParentOrigin::CENTER ); - actor.SetAnchorPoint( AnchorPoint::CENTER ); - actor.SetPosition( x * mTileSize.width + basePosition.x, - positionY, - basePosition.z ); - mRoot.Add( actor ); - - mTiles[ 0 ][idx] = CreateTile( placeHolder, FULL_BRIGHTNESS ); - actor.Add( mTiles[ 0 ][idx] ); - - mTiles[ 1 ][idx] = CreateTile( placeHolder, HALF_BRIGHTNESS ); - actor.Add( mTiles[ 1 ][idx] ); + case LEFT: + case RIGHT: + { + mBoxes[i].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.x * 0.5f); + mBoxes[i].SetProperty(Actor::Property::SIZE_DEPTH, mTileSize.x); + break; + } + case BOTTOM: + case TOP: + { + mBoxes[i].SetProperty(Actor::Property::PARENT_ORIGIN_Z, 1.0f - mTileSize.y * 0.5f); + mBoxes[i].SetProperty(Actor::Property::SIZE_DEPTH, mTileSize.y); + break; + } } } - // helper actor to create a off-screen image using shader effect - mEmptyImage = ImageActor::New( placeHolder ); - mEmptyImage.SetSize(Stage::GetCurrent().GetSize()); - mEmptyImage.SetParentOrigin( ParentOrigin::CENTER ); - mEmptyImage.SetAnchorPoint( AnchorPoint::CENTER ); - mEmptyImage.SetRelayoutEnabled( false ); - mFullImageCreator = FullAreaImageCreator::New(); - mEmptyImage.SetShaderEffect( mFullImageCreator ); - Stage::GetCurrent().Add(mEmptyImage); - - // set up off-screen render task - RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList(); - mOffScreenTask = taskList.CreateTask(); - mOffScreenTask.SetSourceActor(mEmptyImage); - mOffScreenTask.SetExclusive(true); - mOffScreenBuffer[0] = FrameBufferImage::New(mViewAreaSize.x, mViewAreaSize.y); - mOffScreenBuffer[1] = FrameBufferImage::New(mViewAreaSize.x, mViewAreaSize.y); - mOffScreenTask.SetTargetFrameBuffer(mOffScreenBuffer[mBufferIndex]); - mOffScreenTask.SetRefreshRate(RenderTask::REFRESH_ONCE); + for(ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it) + { + it->SetProperty(Actor::Property::SIZE_WIDTH, mTileSize.x); + it->SetProperty(Actor::Property::SIZE_HEIGHT, mTileSize.y); + } + for(ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it) + { + it->SetProperty(Actor::Property::SIZE_WIDTH, mTileSize.x); + it->SetProperty(Actor::Property::SIZE_HEIGHT, mTileSize.y); + } +} + +void CubeTransitionEffect::Initialize() +{ + Self().RegisterProperty("uTextureRect", Vector4(0.0f, 0.0f, 1.0f, 1.0f)); + + mBoxType.Resize(mColumns * mRows); + + //create the box parents + mBoxRoot = Actor::New(); + mBoxRoot.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + mBoxRoot.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + + mCurrentTiles.clear(); + mTargetTiles.clear(); + + mCurrentTiles.reserve(mColumns * mRows); + mTargetTiles.reserve(mColumns * mRows); + + Vector2 gridSizeInv(1.0f / mColumns, 1.0f / mRows); + Vector3 offset(0.5f * gridSizeInv.x, 0.5f * gridSizeInv.y, 0.0f); + + Vector3 anchor; + for(unsigned int y = 0; y < mRows; ++y, anchor.y += 1.0f / mRows) + { + anchor.x = 0.0f; + for(unsigned int x = 0; x < mColumns; ++x, anchor.x += 1.0f / mColumns) + { + Vector4 textureRect(anchor.x, anchor.y, anchor.x + gridSizeInv.x, anchor.y + gridSizeInv.y); + + Actor currentTile = CreateTile(textureRect); + currentTile.SetProperty(Actor::Property::COLOR, FULL_BRIGHTNESS); + currentTile.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); + mCurrentTiles.push_back(currentTile); + + Actor targetTile = CreateTile(textureRect); + targetTile.SetProperty(Actor::Property::COLOR, HALF_BRIGHTNESS); + mTargetTiles.push_back(targetTile); + + Actor box = Actor::New(); + box.SetProperty(Actor::Property::PARENT_ORIGIN, anchor + offset); + box.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER); + + box.Add(currentTile); + box.Add(targetTile); + + mBoxRoot.Add(box); + + mBoxes.push_back(box); + } + } OnInitialize(); } -ImageActor CubeTransitionEffect::CreateTile( Image image, const Vector4& color ) +void CubeTransitionEffect::OnSceneConnection(int depth) { - ImageActor tile = ImageActor::New( image ); - tile.SetParentOrigin( ParentOrigin::CENTER ); - tile.SetAnchorPoint( AnchorPoint::CENTER ); - tile.SetRelayoutEnabled( false ); - tile.SetSize( mTileSize ); - tile.SetColorMode( Dali::USE_OWN_COLOR ); - tile.SetColor( color ); + Geometry geometry = VisualFactoryCache::CreateQuadGeometry(); + Shader shader = Shader::New(SHADER_CUBE_TRANSITION_EFFECT_VERT, SHADER_CUBE_TRANSITION_EFFECT_FRAG); - return tile; + TextureSet textureSet = TextureSet::New(); + + if(mCurrentTexture) + { + textureSet.SetTexture(0u, mCurrentTexture); + } + mCurrentRenderer = Renderer::New(geometry, shader); + mCurrentRenderer.SetTextures(textureSet); + + mCurrentRenderer.SetProperty(Renderer::Property::DEPTH_INDEX, depth); + Self().AddRenderer(mCurrentRenderer); + + Control::OnSceneConnection(depth); } -void CubeTransitionEffect::SetTransitionDuration( float duration ) +void CubeTransitionEffect::OnSceneDisconnection() +{ + if(mCurrentRenderer) + { + Self().RemoveRenderer(mCurrentRenderer); + + for(ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it) + { + it->RemoveRenderer(mCurrentRenderer); + } + mCurrentRenderer.Reset(); + } + + if(mTargetRenderer) + { + for(ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it) + { + it->RemoveRenderer(mTargetRenderer); + } + mTargetRenderer.Reset(); + } + + Control::OnSceneDisconnection(); +} + +void CubeTransitionEffect::SetTransitionDuration(float duration) { mAnimationDuration = duration; } -float CubeTransitionEffect::GetTransitionDuration( ) const +float CubeTransitionEffect::GetTransitionDuration() const { return mAnimationDuration; } -void CubeTransitionEffect::SetCubeDisplacement( float displacement ) +void CubeTransitionEffect::SetCubeDisplacement(float displacement) { mCubeDisplacement = displacement; } @@ -170,99 +274,102 @@ float CubeTransitionEffect::GetCubeDisplacement() const return mCubeDisplacement; } -Actor CubeTransitionEffect::GetRoot() +bool CubeTransitionEffect::IsTransitioning() { - return mRoot; + return mIsAnimating; } -bool CubeTransitionEffect::IsTransiting() +void CubeTransitionEffect::SetCurrentTexture(Texture texture) { - return mIsImageLoading || mIsAnimating; -} + mCurrentTexture = texture; -void CubeTransitionEffect::SetCurrentImage( ImageActor imageActor ) -{ - mContainerIndex = std::abs(mRotateIndex) % 2; - SetImage( imageActor ); -} - -void CubeTransitionEffect::SetTargetImage( ImageActor imageActor ) -{ - mContainerIndex = std::abs( mRotateIndex+1 ) % 2; - SetImage( imageActor ); + if(mCurrentRenderer) + { + TextureSet textureSet = mCurrentRenderer.GetTextures(); + textureSet.SetTexture(0u, mCurrentTexture); + } } -void CubeTransitionEffect::SetImage( ImageActor imageActor ) +void CubeTransitionEffect::SetTargetTexture(Texture texture) { - mCurrentImage = imageActor; + mTargetTexture = texture; - Image image = imageActor.GetImage(); - ResourceImage resourceImage = ResourceImage::DownCast( image ); - mBufferIndex = mBufferIndex^1; - - //must make sure the image is already loaded before using its attributes - if( resourceImage && resourceImage.GetLoadingState() != ResourceLoadingSucceeded ) - { - mIsImageLoading = true; - resourceImage.LoadingFinishedSignal().Connect( this, &CubeTransitionEffect::OnImageLoaded ); - } - else + if(mTargetRenderer) { - mIsImageLoading = false; - PrepareTiles( image ); + TextureSet textureSet = mTargetRenderer.GetTextures(); + textureSet.SetTexture(0u, mTargetTexture); } } -void CubeTransitionEffect::StartTransition( bool toNextImage ) +void CubeTransitionEffect::StartTransition(bool toNextImage) { - if( toNextImage ) + Vector3 size = Self().GetCurrentProperty(Actor::Property::SIZE); + if(toNextImage) { - StartTransition( Vector2( mViewAreaSize.width, mViewAreaSize.height*0.5f ), Vector2( -10.f, 0.f ) ); + StartTransition(Vector2(size.x * 0.5f, size.y * 0.5f), Vector2(-10.f, 0.f)); } else { - StartTransition( Vector2( 0, mViewAreaSize.height*0.5f ), Vector2( 10.f, 0.f )); + StartTransition(Vector2(size.x * 0.5f, size.y * 0.5f), Vector2(10.f, 0.f)); } } -void CubeTransitionEffect::StartTransition( Vector2 panPosition, Vector2 panDisplacement ) +void CubeTransitionEffect::StartTransition(Vector2 panPosition, Vector2 panDisplacement) { - mRoot.SetVisible( true ); - mCurrentImage.SetVisible( false ); - bool toNextImage = ( panDisplacement.x < 0 ) ? true : false; - if( mIsToNextImage != toNextImage ) + if(!mCurrentRenderer) { - mChangeTurningDirection = true; + DALI_LOG_ERROR("Trying to transition a cube transition without an image set\n"); + return; } - else + + //create the target renderer + TextureSet textureSet = TextureSet::New(); + if(mTargetTexture) { - mChangeTurningDirection = false; + textureSet.SetTexture(0u, mTargetTexture); } - mIsToNextImage = toNextImage; + Geometry geometry = mCurrentRenderer.GetGeometry(); + Shader shader(mCurrentRenderer.GetShader()); + mTargetRenderer = Renderer::New(geometry, shader); + mTargetRenderer.SetTextures(textureSet); - if( mIsToNextImage ) + int depthIndex = mCurrentRenderer.GetProperty(Renderer::Property::DEPTH_INDEX); + mTargetRenderer.SetProperty(Dali::Renderer::Property::DEPTH_INDEX, depthIndex); + + for(size_t i = 0; i < mBoxes.size(); ++i) { - mRotateIndex += 1.f; + mBoxes[i].SetProperty(Actor::Property::ORIENTATION, Quaternion(Radian(0.0f), Vector3::XAXIS)); } - else + + for(ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it) + { + it->SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 0.5f, 1.0f)); + it->SetProperty(Actor::Property::ORIENTATION, Quaternion(Radian(0.0f), Vector3::XAXIS)); + it->AddRenderer(mCurrentRenderer); + } + for(ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it) { - mRotateIndex -= 1.f; + it->AddRenderer(mTargetRenderer); } + Self().RemoveRenderer(mCurrentRenderer); + Self().Add(mBoxRoot); + if(mAnimation) { mAnimation.Clear(); mAnimation.Reset(); } - mAnimation = Animation::New( mAnimationDuration ); + + mAnimation = Animation::New(mAnimationDuration); mAnimation.FinishedSignal().Connect(this, &CubeTransitionEffect::OnTransitionFinished); - OnStartTransition( panPosition, panDisplacement ); + OnStartTransition(panPosition, panDisplacement); } void CubeTransitionEffect::PauseTransition() { - if( mIsAnimating && !mIsPaused ) + if(mIsAnimating && !mIsPaused) { mAnimation.Pause(); mIsPaused = true; @@ -271,7 +378,7 @@ void CubeTransitionEffect::PauseTransition() void CubeTransitionEffect::ResumeTransition() { - if( mIsAnimating && mIsPaused) + if(mIsAnimating && mIsPaused) { mAnimation.Play(); mIsPaused = false; @@ -280,91 +387,61 @@ void CubeTransitionEffect::ResumeTransition() void CubeTransitionEffect::StopTransition() { - if( mIsAnimating ) - { - mAnimation.Clear(); - mAnimation.Reset(); - mIsPaused = false; - - //reset the position of the cubes - //reset the color of the tiles - //all these status should be the same as the final state when the transition animation is finished completely - const Vector3 basePosition( (-mViewAreaSize.width + mTileSize.width) * 0.5f, - (-mViewAreaSize.height + mTileSize.height) * 0.5f, - -mTileSize.width * 0.5f ); - unsigned int anotherIndex = mContainerIndex^1; - for( unsigned int y = 0; y < mNumRows; y++ ) - { - float positionY = y * mTileSize.height + basePosition.y; - for( unsigned int x = 0; x < mNumColumns; x++) - { - unsigned int idx = y*mNumColumns + x; - mBoxes[idx].SetPosition( x * mTileSize.width + basePosition.x, - positionY, - basePosition.z ); - mTiles[mContainerIndex][idx].SetColor( FULL_BRIGHTNESS ); - mTiles[anotherIndex][idx].SetColor( HALF_BRIGHTNESS); - } - } - - // reset the rotation of the cubes, which is different process for different derived classes - OnStopTransition(); - - mRoot.SetVisible(false); - mCurrentImage.SetVisible(true); - mIsAnimating = false; - mFirstTransition = false; - } + ResetToInitialState(); } -void CubeTransitionEffect::OnImageLoaded(ResourceImage image) +void CubeTransitionEffect::ResetToInitialState() { - mIsImageLoading = false; - PrepareTiles( image ); -} - -/** - * Set sub-image to each tile. - * @param[in] image The image content of the imageActor for transition - */ -void CubeTransitionEffect::PrepareTiles( Image image ) -{ - // Fit the image to view area, while keeping the aspect; FitKeepAspectRatio(imageSize, viewAreaSize) - float scale = std::min( mViewAreaSize.width / image.GetWidth(), mViewAreaSize.height / image.GetHeight() ); - Vector2 imageSize(image.GetWidth()*scale, image.GetHeight()*scale); + mAnimation.Clear(); + mAnimation.Reset(); + mIsAnimating = false; - mFullImageCreator.SetEffectImage(image); - mFullImageCreator.SetRegionSize(mViewAreaSize, imageSize); + Self().Remove(mBoxRoot); - mOffScreenTask.SetTargetFrameBuffer(mOffScreenBuffer[mBufferIndex]); - mOffScreenTask.SetRefreshRate(RenderTask::REFRESH_ONCE); + for(size_t i = 0; i < mBoxes.size(); ++i) + { + mBoxes[i].SetProperty(Actor::Property::ORIENTATION, Quaternion(Radian(0.0f), Vector3::XAXIS)); + } - ImageActor::PixelArea pixelArea( 0, 0, mViewAreaSize.x / mNumColumns, mViewAreaSize.y / mNumRows); + for(ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it) + { + it->SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, 0.5f, 1.0f)); + it->SetProperty(Actor::Property::ORIENTATION, Quaternion(Radian(0.0f), Vector3::XAXIS)); + it->SetProperty(Actor::Property::COLOR, FULL_BRIGHTNESS); + } + if(mCurrentRenderer) + { + for(ActorArray::iterator it = mCurrentTiles.begin(); it != mCurrentTiles.end(); ++it) + { + it->RemoveRenderer(mCurrentRenderer); + } + Self().AddRenderer(mCurrentRenderer); + } - for( unsigned int y = 0; y < mNumRows; y++ ) + for(ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it) + { + it->SetProperty(Actor::Property::COLOR, HALF_BRIGHTNESS); + } + if(mTargetRenderer) { - pixelArea.y = y * pixelArea.height; - for( unsigned int x = 0; x < mNumColumns; x++) + for(ActorArray::iterator it = mTargetTiles.begin(); it != mTargetTiles.end(); ++it) { - pixelArea.x = x * pixelArea.width; - unsigned int idx = y*mNumColumns + x; - mTiles[mContainerIndex][idx].SetImage( mOffScreenBuffer[mBufferIndex]); - mTiles[mContainerIndex][idx].SetPixelArea( pixelArea ); + it->RemoveRenderer(mTargetRenderer); } } } - void CubeTransitionEffect::OnTransitionFinished(Animation& source) { - mRoot.SetVisible(false); - mCurrentImage.SetVisible(true); - mIsAnimating = false; - mFirstTransition = false; + std::swap(mCurrentTiles, mTargetTiles); + std::swap(mCurrentRenderer, mTargetRenderer); + std::swap(mCurrentTexture, mTargetTexture); + + ResetToInitialState(); //Emit signal - Toolkit::CubeTransitionEffect handle( this ); - mTransitionCompletedSignal.Emit( handle, mCurrentImage ); + Toolkit::CubeTransitionEffect handle(GetOwner()); + mTransitionCompletedSignal.Emit(handle, mCurrentTexture); } Toolkit::CubeTransitionEffect::TransitionCompletedSignalType& CubeTransitionEffect::TransitionCompletedSignal() @@ -372,16 +449,16 @@ Toolkit::CubeTransitionEffect::TransitionCompletedSignalType& CubeTransitionEffe return mTransitionCompletedSignal; } -bool CubeTransitionEffect::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor ) +bool CubeTransitionEffect::DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor) { - Dali::BaseHandle handle( object ); + Dali::BaseHandle handle(object); - bool connected( true ); - Toolkit::CubeTransitionEffect cubeTransitionEffect = Toolkit::CubeTransitionEffect::DownCast( handle ); + bool connected(true); + Toolkit::CubeTransitionEffect cubeTransitionEffect = Toolkit::CubeTransitionEffect::DownCast(handle); - if( 0 == strcmp( signalName.c_str(), SIGNAL_TRANSITION_COMPLETED ) ) + if(0 == strcmp(signalName.c_str(), SIGNAL_TRANSITION_COMPLETED)) { - cubeTransitionEffect.TransitionCompletedSignal().Connect( tracker, functor ); + cubeTransitionEffect.TransitionCompletedSignal().Connect(tracker, functor); } else {