dali-toolkit/internal/text/clipping/text-clipper.cpp

   1 /*
   2  * Copyright (c) 2015 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/text/clipping/text-clipper.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/common/stage.h>
  23 #include <dali/public-api/render-tasks/render-task-list.h>
  24 #include <dali/devel-api/rendering/renderer.h>
  25
  26 namespace
  27 {
  28
  29 // Currently on desktop machines 2k x 2k is the maximum frame buffer size, on target is 4k x 4k.
  30 const float MAX_OFFSCREEN_RENDERING_SIZE = 2048.f;
  31
  32 } // namespace
  33
  34
  35 namespace Dali
  36 {
  37
  38 namespace Toolkit
  39 {
  40
  41 namespace Text
  42 {
  43
  44 ClipperPtr Clipper::New( const Vector2& size )
  45 {
  46   ClipperPtr clipper( new Clipper() );
  47
  48   // Second-phase init
  49   clipper->Initialize( size );
  50
  51   return clipper;
  52 }
  53
  54 Actor Clipper::GetRootActor() const
  55 {
  56   return mOffscreenRootActor;
  57 }
  58
  59 Actor Clipper::GetImageActor() const
  60 {
  61   return mImageActor;
  62 }
  63
  64 void Clipper::Refresh( const Vector2& size )
  65 {
  66   const Size offscreenSize( std::min( MAX_OFFSCREEN_RENDERING_SIZE, size.width ),
  67                             std::min( MAX_OFFSCREEN_RENDERING_SIZE, size.height ) );
  68
  69   const bool sizeChanged = offscreenSize != mCurrentOffscreenSize;
  70
  71   if( sizeChanged )
  72   {
  73     // Reconfigure camera for current size.
  74     mOffscreenCameraActor.SetOrthographicProjection( offscreenSize );
  75
  76     // Recreate frame buffer for offscreen rendering when the size changes.
  77     FrameBufferImage frameBufferImage = FrameBufferImage::New( offscreenSize.width,
  78                                                                offscreenSize.height,
  79                                                                Pixel::RGBA8888 );
  80
  81     mOffscreenRootActor.SetSize( size );
  82
  83     mImageActor.SetSize( offscreenSize );
  84     mImageActor.SetImage( frameBufferImage );
  85     mRenderTask.SetTargetFrameBuffer( frameBufferImage );
  86
  87     // Stores current sizPe to avoid create new Dali resources if text changes.
  88     mCurrentOffscreenSize = offscreenSize;
  89   }
  90
  91   mRenderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
  92 }
  93
  94 void Clipper::Initialize( const Vector2& size )
  95 {
  96   const Size offscreenSize( std::min( MAX_OFFSCREEN_RENDERING_SIZE, size.width ),
  97                             std::min( MAX_OFFSCREEN_RENDERING_SIZE, size.height ) );
  98
  99   // Create a root actor and an image actor for offscreen rendering.
 100   mOffscreenRootActor = Layer::New();
 101   mOffscreenRootActor.SetColorMode( USE_OWN_COLOR );
 102   mOffscreenRootActor.SetInheritPosition( false );
 103   mOffscreenRootActor.SetInheritScale( false );
 104   mOffscreenRootActor.SetDepthTestDisabled( true );
 105   mOffscreenRootActor.SetSize( offscreenSize );
 106
 107   mImageActor = ImageView::New();
 108   mImageActor.SetParentOrigin( ParentOrigin::CENTER );
 109   mImageActor.SetScale( Vector3( 1.0f, -1.0f, 1.0f ) );
 110   mImageActor.SetSize( offscreenSize );
 111
 112   // Creates a new camera actor.
 113   mOffscreenCameraActor = CameraActor::New();
 114   mOffscreenCameraActor.SetParentOrigin( ParentOrigin::CENTER );
 115   mOffscreenCameraActor.SetOrthographicProjection( offscreenSize );
 116   mOffscreenRootActor.Add( mOffscreenCameraActor ); // camera to shoot the offscreen text
 117
 118   // Creates a new render task.
 119   mRenderTask = Stage::GetCurrent().GetRenderTaskList().CreateTask();
 120   mRenderTask.SetSourceActor( mOffscreenRootActor );
 121   mRenderTask.SetClearColor( Color::TRANSPARENT );
 122   mRenderTask.SetClearEnabled( true );
 123   mRenderTask.SetExclusive( true );
 124   mRenderTask.SetCameraActor( mOffscreenCameraActor );
 125
 126   // Creates a frame buffer for offscreen rendering
 127   FrameBufferImage frameBufferImage = FrameBufferImage::New( offscreenSize.width,
 128                                                              offscreenSize.height,
 129                                                              Pixel::RGBA8888 );
 130   mImageActor.SetImage( frameBufferImage );
 131   mRenderTask.SetTargetFrameBuffer( frameBufferImage );
 132   mImageActor.OnStageSignal().Connect(this, &Clipper::OnStageConnect);
 133
 134   // Stores current size to avoid create new Dali resources if text changes.
 135   mCurrentOffscreenSize = offscreenSize;
 136 }
 137
 138 void Clipper::OnStageConnect( Dali::Actor actor )
 139 {
 140   Renderer renderer = mImageActor.GetRendererAt(0);
 141   renderer.SetBlendFunc(BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA,
 142                         BlendingFactor::ONE, BlendingFactor::ONE);
 143 }
 144
 145 Clipper::Clipper()
 146 {
 147 }
 148
 149 Clipper::~Clipper()
 150 {
 151   if( Stage::IsInstalled() )
 152   {
 153     UnparentAndReset( mOffscreenRootActor );
 154     UnparentAndReset( mImageActor );
 155
 156     Stage::GetCurrent().GetRenderTaskList().RemoveTask( mRenderTask );
 157   }
 158 }
 159
 160 } // namespace Text
 161
 162 } // namespace Toolkit
 163
 164 } // namespace Dali