dali/internal/render/queue/render-queue.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 // CLASS HEADER
  18 #include <dali/internal/render/queue/render-queue.h>
  19
  20 // INTERNAL INCLUDES
  21 #include <dali/internal/common/message.h>
  22
  23 namespace Dali
  24 {
  25
  26 namespace Internal
  27 {
  28
  29 namespace // unnamed namespace
  30 {
  31
  32 static const std::size_t INITIAL_BUFFER_SIZE = 32768;
  33 static const std::size_t MAX_BUFFER_SIZE     = 32768;
  34
  35 } // unnamed namespace
  36
  37 namespace SceneGraph
  38 {
  39
  40 RenderQueue::RenderQueue()
  41 : container0( NULL ),
  42   container1( NULL )
  43 {
  44   container0 = new MessageBuffer( INITIAL_BUFFER_SIZE );
  45   container1 = new MessageBuffer( INITIAL_BUFFER_SIZE );
  46 }
  47
  48 RenderQueue::~RenderQueue()
  49 {
  50   if( container0 )
  51   {
  52     for( MessageBuffer::Iterator iter = container0->Begin(); iter.IsValid(); iter.Next() )
  53     {
  54       MessageBase* message = reinterpret_cast< MessageBase* >( iter.Get() );
  55
  56       // Call virtual destructor explictly; since delete will not be called after placement new
  57       message->~MessageBase();
  58     }
  59
  60     delete container0;
  61   }
  62
  63   if( container1 )
  64   {
  65     for( MessageBuffer::Iterator iter = container1->Begin(); iter.IsValid(); iter.Next() )
  66     {
  67       MessageBase* message = reinterpret_cast< MessageBase* >( iter.Get() );
  68
  69       // Call virtual destructor explictly; since delete will not be called after placement new
  70       message->~MessageBase();
  71     }
  72
  73     delete container1;
  74   }
  75 }
  76
  77 unsigned int* RenderQueue::ReserveMessageSlot( BufferIndex updateBufferIndex, std::size_t size )
  78 {
  79   MessageBuffer* container = GetCurrentContainer( updateBufferIndex );
  80
  81   return container->ReserveMessageSlot( size );
  82 }
  83
  84 void RenderQueue::ProcessMessages( BufferIndex bufferIndex )
  85 {
  86   MessageBuffer* container = GetCurrentContainer( bufferIndex );
  87
  88   for( MessageBuffer::Iterator iter = container->Begin(); iter.IsValid(); iter.Next() )
  89   {
  90     MessageBase* message = reinterpret_cast< MessageBase* >( iter.Get() );
  91
  92     message->Process( bufferIndex );
  93
  94     // Call virtual destructor explictly; since delete will not be called after placement new
  95     message->~MessageBase();
  96   }
  97
  98   container->Reset();
  99
 100   LimitBufferCapacity( bufferIndex );
 101 }
 102
 103 MessageBuffer* RenderQueue::GetCurrentContainer( BufferIndex bufferIndex )
 104 {
 105   MessageBuffer* container( NULL );
 106
 107   /**
 108    * The update-thread queues messages with one container,
 109    * whilst the render-thread is processing the other.
 110    */
 111   if ( !bufferIndex )
 112   {
 113     container = container0;
 114   }
 115   else
 116   {
 117     container = container1;
 118   }
 119
 120   return container;
 121 }
 122
 123 void RenderQueue::LimitBufferCapacity( BufferIndex bufferIndex )
 124 {
 125   if ( !bufferIndex )
 126   {
 127     if( MAX_BUFFER_SIZE < container0->GetCapacity() )
 128     {
 129       delete container0;
 130       container0 = NULL;
 131       container0 = new MessageBuffer( INITIAL_BUFFER_SIZE );
 132     }
 133   }
 134   else
 135   {
 136     if( MAX_BUFFER_SIZE < container1->GetCapacity() )
 137     {
 138       delete container1;
 139       container1 = NULL;
 140       container1 = new MessageBuffer( INITIAL_BUFFER_SIZE );
 141     }
 142   }
 143 }
 144
 145 } // namespace SceneGraph
 146
 147 } // namespace Internal
 148
 149 } // namespace Dali