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