dali/internal/event/common/property-buffer-impl.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/event/common/property-buffer-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/rendering/property-buffer.h>
  23 #include <dali/internal/event/common/stage-impl.h>
  24 #include <dali/internal/update/manager/update-manager.h>
  25
  26 namespace Dali
  27 {
  28 namespace Internal
  29 {
  30
  31 namespace
  32 {
  33
  34 /**
  35  * Calculate the alignment requirements of a type
  36  *
  37  * This is used to calculate the memory alignment requirements of a type
  38  * It creates a structure with a dummy char and a member of the type we want to check
  39  * this will cause the second member to be aligned by it's alignment requirement.
  40  */
  41 template<Property::Type type>
  42 struct PropertyImplementationTypeAlignment
  43 {
  44   // Create a structure that forces alignment of the data type
  45   struct TestStructure
  46   {
  47     char oneChar;  ///< Member with sizeof() == 1
  48     typename PropertyImplementationType<type>::Type data;
  49   };
  50   enum { VALUE = offsetof( TestStructure, data ) };
  51 };
  52
  53 uint32_t GetPropertyImplementationAlignment( Property::Type& propertyType )
  54 {
  55   uint32_t alignment = 0u;
  56
  57   switch( propertyType )
  58   {
  59     case Property::BOOLEAN:
  60     {
  61       alignment = PropertyImplementationTypeAlignment< Property::BOOLEAN >::VALUE;
  62       break;
  63     }
  64     case Property::INTEGER:
  65     {
  66       alignment = PropertyImplementationTypeAlignment< Property::INTEGER >::VALUE;
  67       break;
  68     }
  69     case Property::FLOAT:
  70     {
  71       alignment = PropertyImplementationTypeAlignment< Property::FLOAT >::VALUE;
  72       break;
  73     }
  74     case Property::VECTOR2:
  75     {
  76       alignment = PropertyImplementationTypeAlignment< Property::VECTOR2 >::VALUE;
  77       break;
  78     }
  79     case Property::VECTOR3:
  80     {
  81       alignment = PropertyImplementationTypeAlignment< Property::VECTOR3 >::VALUE;
  82       break;
  83     }
  84     case Property::VECTOR4:
  85     {
  86       alignment = PropertyImplementationTypeAlignment< Property::VECTOR4 >::VALUE;
  87       break;
  88     }
  89     case Property::MATRIX3:
  90     {
  91       alignment = PropertyImplementationTypeAlignment< Property::MATRIX3 >::VALUE;
  92       break;
  93     }
  94     case Property::MATRIX:
  95     {
  96       alignment = PropertyImplementationTypeAlignment< Property::MATRIX >::VALUE;
  97       break;
  98     }
  99     case Property::RECTANGLE:
 100     {
 101       alignment = PropertyImplementationTypeAlignment< Property::RECTANGLE >::VALUE;
 102       break;
 103     }
 104     case Property::ROTATION:
 105     {
 106       alignment = PropertyImplementationTypeAlignment< Property::ROTATION >::VALUE;
 107       break;
 108     }
 109     case Property::NONE:
 110     case Property::STRING:
 111     case Property::ARRAY:
 112     case Property::MAP:
 113     case Property::EXTENTS:
 114     {
 115       // already handled by higher level code
 116     }
 117   }
 118
 119   return alignment;
 120 }
 121
 122 } // unnamed namespace
 123
 124 PropertyBufferPtr PropertyBuffer::New( Dali::Property::Map& format )
 125 {
 126   DALI_ASSERT_ALWAYS( format.Count() && "Format cannot be empty." );
 127
 128   PropertyBufferPtr propertyBuffer( new PropertyBuffer() );
 129   propertyBuffer->Initialize( format );
 130
 131   return propertyBuffer;
 132 }
 133
 134 void PropertyBuffer::SetData( const void* data, uint32_t size )
 135 {
 136   mSize = size; // size is the number of elements
 137
 138   uint32_t bufferSize = mBufferFormatSize * mSize;
 139
 140   // create a new DALi vector to store the buffer data
 141   // the heap allocated vector will end up being owned by Render::PropertyBuffer
 142   OwnerPointer< Vector<uint8_t> > bufferCopy = new Dali::Vector<uint8_t>();
 143   bufferCopy->Resize( bufferSize );
 144
 145   // copy the data
 146   const uint8_t* source = static_cast<const uint8_t*>( data );
 147   uint8_t* destination = &((*bufferCopy)[0]);
 148   std::copy( source, source + bufferSize, destination );
 149
 150   // Ownership of the bufferCopy is passed to the message ( uses an owner pointer )
 151   SceneGraph::SetPropertyBufferData( mEventThreadServices.GetUpdateManager(), *mRenderObject, bufferCopy, mSize );
 152 }
 153
 154 uint32_t PropertyBuffer::GetSize() const
 155 {
 156   return mSize;
 157 }
 158
 159 const Render::PropertyBuffer* PropertyBuffer::GetRenderObject() const
 160 {
 161   return mRenderObject;
 162 }
 163
 164 PropertyBuffer::~PropertyBuffer()
 165 {
 166   if( EventThreadServices::IsCoreRunning() && mRenderObject)
 167   {
 168     SceneGraph::RemovePropertyBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject );
 169   }
 170 }
 171
 172 PropertyBuffer::PropertyBuffer()
 173 : mEventThreadServices( *Stage::GetCurrent() ),
 174   mRenderObject( NULL ),
 175   mBufferFormatSize( 0 ),
 176   mSize( 0 )
 177 {
 178 }
 179
 180 void PropertyBuffer::Initialize( Dali::Property::Map& formatMap )
 181 {
 182   mRenderObject = new Render::PropertyBuffer();
 183   OwnerPointer< Render::PropertyBuffer > transferOwnership( mRenderObject );
 184   SceneGraph::AddPropertyBuffer( mEventThreadServices.GetUpdateManager(), transferOwnership );
 185
 186   uint32_t numComponents = static_cast<uint32_t>( formatMap.Count() );
 187
 188   // Create the format
 189   OwnerPointer< Render::PropertyBuffer::Format> format = new Render::PropertyBuffer::Format();
 190   format->components.resize( numComponents );
 191
 192   uint32_t currentAlignment = 0u;
 193   uint32_t maxAlignmentRequired = 0u;
 194
 195   for( uint32_t i = 0u; i < numComponents; ++i )
 196   {
 197     KeyValuePair component = formatMap.GetKeyValue( i );
 198
 199     // Get the name
 200     if(component.first.type == Property::Key::INDEX)
 201     {
 202       continue;
 203     }
 204     format->components[i].name = component.first.stringKey;
 205
 206     // enums are stored in the map as int
 207     Property::Type type = Property::Type( component.second.Get<int>() );
 208
 209     // Get the size and alignment
 210     if( ( type == Property::NONE   ) ||
 211         ( type == Property::STRING ) ||
 212         ( type == Property::ARRAY  ) ||
 213         ( type == Property::MAP    ) )
 214     {
 215       DALI_ABORT( "Property::Type not supported in PropertyBuffer" );
 216     }
 217     uint32_t elementSize = GetPropertyImplementationSize( type );
 218     uint32_t elementAlignment = GetPropertyImplementationAlignment( type );
 219
 220     // check if current alignment is compatible with new member
 221     if( uint32_t offset = currentAlignment % elementAlignment )
 222     {
 223       // Not compatible, realign
 224       currentAlignment = currentAlignment + elementSize - offset;
 225     }
 226
 227     // write to the format
 228     format->components[i].size = elementSize;
 229     format->components[i].offset = currentAlignment;
 230     format->components[i].type = type;
 231
 232     // update offset
 233     currentAlignment += elementSize;
 234
 235     // update max alignment requirement
 236     if( elementAlignment > maxAlignmentRequired )
 237     {
 238       maxAlignmentRequired = elementAlignment;
 239     }
 240
 241   }
 242
 243   // Check the alignment for the maxAlignment required to calculate the size of the format
 244   if( maxAlignmentRequired != 0 )
 245   {
 246     if( uint32_t offset = currentAlignment % maxAlignmentRequired )
 247     {
 248       // Not compatible, realign
 249       currentAlignment = currentAlignment + maxAlignmentRequired - offset;
 250     }
 251   }
 252
 253   // Set the format size
 254   format->size = currentAlignment;
 255
 256   mBufferFormatSize = format->size;
 257
 258   SceneGraph::SetPropertyBufferFormat(mEventThreadServices.GetUpdateManager(), *mRenderObject, format );
 259 }
 260
 261 uint32_t GetPropertyImplementationSize( Property::Type& propertyType )
 262 {
 263   uint32_t size = 0u;
 264
 265   switch( propertyType )
 266   {
 267     case Property::BOOLEAN:
 268     {
 269       size = sizeof( PropertyImplementationType< Property::BOOLEAN >::Type );
 270       break;
 271     }
 272     case Property::INTEGER:
 273     {
 274       size = sizeof( PropertyImplementationType< Property::INTEGER >::Type );
 275       break;
 276     }
 277     case Property::FLOAT:
 278     {
 279       size = sizeof( PropertyImplementationType< Property::FLOAT >::Type );
 280       break;
 281     }
 282     case Property::VECTOR2:
 283     {
 284       size = sizeof( PropertyImplementationType< Property::VECTOR2 >::Type );
 285       break;
 286     }
 287     case Property::VECTOR3:
 288     {
 289       size = sizeof( PropertyImplementationType< Property::VECTOR3 >::Type );
 290       break;
 291     }
 292     case Property::VECTOR4:
 293     {
 294       size = sizeof( PropertyImplementationType< Property::VECTOR4 >::Type );
 295       break;
 296     }
 297     case Property::MATRIX3:
 298     {
 299       size = sizeof( PropertyImplementationType< Property::MATRIX3 >::Type );
 300       break;
 301     }
 302     case Property::MATRIX:
 303     {
 304       size = sizeof( PropertyImplementationType< Property::MATRIX >::Type );
 305       break;
 306     }
 307     case Property::RECTANGLE:
 308     {
 309       size = sizeof( PropertyImplementationType< Property::RECTANGLE >::Type );
 310       break;
 311     }
 312     case Property::ROTATION:
 313     {
 314       size = sizeof( PropertyImplementationType< Property::ROTATION >::Type );
 315       break;
 316     }
 317     case Property::NONE:
 318     case Property::STRING:
 319     case Property::ARRAY:
 320     case Property::MAP:
 321     case Property::EXTENTS:
 322     {
 323       // already handled by higher level code
 324     }
 325   }
 326
 327   return size;
 328 }
 329
 330
 331 } // namespace Internal
 332 } // namespace Dali