dali/internal/common/blending-options.cpp

   1 /*
   2  * Copyright (c) 2014 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/common/blending-options.h>
  20
  21 namespace // unnamed namespace
  22 {
  23
  24 using namespace Dali;
  25
  26 const int MASK_SRC_FACTOR_RGB    = 0x0000000F;
  27 const int MASK_SRC_FACTOR_ALPHA  = 0x000000F0;
  28 const int MASK_DEST_FACTOR_RGB   = 0x00000F00;
  29 const int MASK_DEST_FACTOR_ALPHA = 0x0000F000;
  30 const int MASK_EQUATION_RGB      = 0x000F0000;
  31 const int MASK_EQUATION_ALPHA    = 0x00F00000;
  32
  33 const int SHIFT_TO_SRC_FACTOR_RGB    =  0;
  34 const int SHIFT_TO_SRC_FACTOR_ALPHA  =  4;
  35 const int SHIFT_TO_DEST_FACTOR_RGB   =  8;
  36 const int SHIFT_TO_DEST_FACTOR_ALPHA = 12;
  37 const int SHIFT_TO_EQUATION_RGB      = 16;
  38 const int SHIFT_TO_EQUATION_ALPHA    = 20;
  39
  40 static unsigned int CLEAR_BLEND_FUNC_MASK     = 0xFFFF0000; // Bottom 16 bits cleared
  41 static unsigned int CLEAR_BLEND_EQUATION_MASK = 0xFF00FFFF; // 8 bits cleared
  42
  43 /**
  44  * Utility to store one of the BlendFunc values.
  45  * @param[out] options A bitmask used to store the BlendFunc values.
  46  * @param[in] factor The BlendFunc value.
  47  * @param[in] bitshift Used to shift to the correct part of options.
  48  */
  49 void StoreBlendFactor( unsigned int& options, BlendFactor::Type factor, int bitShift )
  50 {
  51   switch( factor )
  52   {
  53     case BlendFactor::ZERO:
  54     {
  55       options |= ( 0u << bitShift );
  56       break;
  57     }
  58
  59     case BlendFactor::ONE:
  60     {
  61       options |= ( 1u << bitShift );
  62       break;
  63     }
  64
  65     case BlendFactor::SRC_COLOR:
  66     {
  67       options |= ( 2u << bitShift );
  68       break;
  69     }
  70
  71     case BlendFactor::ONE_MINUS_SRC_COLOR:
  72     {
  73       options |= ( 3u << bitShift );
  74       break;
  75     }
  76
  77     case BlendFactor::SRC_ALPHA:
  78     {
  79       options |= ( 4u << bitShift );
  80       break;
  81     }
  82
  83     case BlendFactor::ONE_MINUS_SRC_ALPHA:
  84     {
  85       options |= ( 5u << bitShift );
  86       break;
  87     }
  88
  89     case BlendFactor::DST_ALPHA:
  90     {
  91       options |= ( 6u << bitShift );
  92       break;
  93     }
  94
  95     case BlendFactor::ONE_MINUS_DST_ALPHA:
  96     {
  97       options |= ( 7u << bitShift );
  98       break;
  99     }
 100
 101     case BlendFactor::DST_COLOR:
 102     {
 103       options |= ( 8u << bitShift );
 104       break;
 105     }
 106
 107     case BlendFactor::ONE_MINUS_DST_COLOR:
 108     {
 109       options |= ( 9u << bitShift );
 110       break;
 111     }
 112
 113     case BlendFactor::SRC_ALPHA_SATURATE:
 114     {
 115       options |= ( 10u << bitShift );
 116       break;
 117     }
 118
 119     case BlendFactor::CONSTANT_COLOR:
 120     {
 121       options |= ( 11u << bitShift );
 122       break;
 123     }
 124
 125     case BlendFactor::ONE_MINUS_CONSTANT_COLOR:
 126     {
 127       options |= ( 12u << bitShift );
 128       break;
 129     }
 130
 131     case BlendFactor::CONSTANT_ALPHA:
 132     {
 133       options |= ( 13u << bitShift );
 134       break;
 135     }
 136
 137     case BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
 138     {
 139       options |= ( 14u << bitShift );
 140       break;
 141     }
 142   }
 143 }
 144
 145 /**
 146  * Utility to store one of the BlendEquation values.
 147  * @param[out] options A bitmask used to store the BlendEquation values.
 148  * @param[in] factor The BlendEquation value.
 149  * @param[in] bitshift Used to shift to the correct part of options.
 150  */
 151 void StoreBlendEquation( unsigned int& options, BlendEquation::Type factor, int bitShift )
 152 {
 153   switch ( factor )
 154   {
 155     case BlendEquation::ADD:
 156     {
 157       options |= ( 0u << bitShift );
 158       break;
 159     }
 160
 161     case BlendEquation::SUBTRACT:
 162     {
 163       options |= ( 1u << bitShift );
 164       break;
 165     }
 166
 167     case BlendEquation::REVERSE_SUBTRACT:
 168     {
 169       options |= ( 2u << bitShift );
 170       break;
 171     }
 172   }
 173 }
 174
 175 const unsigned int BLENDING_FACTOR_COUNT   = 15;
 176 const unsigned int BLENDING_EQUATION_COUNT = 3;
 177
 178 BlendFactor::Type BLENDING_FACTORS[ BLENDING_FACTOR_COUNT ] =
 179   { BlendFactor::ZERO,
 180     BlendFactor::ONE,
 181     BlendFactor::SRC_COLOR,
 182     BlendFactor::ONE_MINUS_SRC_COLOR,
 183     BlendFactor::SRC_ALPHA,
 184     BlendFactor::ONE_MINUS_SRC_ALPHA,
 185     BlendFactor::DST_ALPHA,
 186     BlendFactor::ONE_MINUS_DST_ALPHA,
 187     BlendFactor::DST_COLOR,
 188     BlendFactor::ONE_MINUS_DST_COLOR,
 189     BlendFactor::SRC_ALPHA_SATURATE,
 190     BlendFactor::CONSTANT_COLOR,
 191     BlendFactor::ONE_MINUS_CONSTANT_COLOR,
 192     BlendFactor::CONSTANT_ALPHA,
 193     BlendFactor::ONE_MINUS_CONSTANT_ALPHA };
 194
 195 BlendEquation::Type BLENDING_EQUATIONS[ BLENDING_EQUATION_COUNT ] =
 196   { BlendEquation::ADD,
 197     BlendEquation::SUBTRACT,
 198     BlendEquation::REVERSE_SUBTRACT };
 199
 200 /**
 201  * Utility to retrieve one of the BlendFunc values.
 202  * @param[in] options A bitmask of blending values.
 203  * @param[in] mask The used to mask unwanted values.
 204  * @param[in] bitshift Used to shift to the correct part of options.
 205  * @return The blending factor.
 206  */
 207 BlendFactor::Type RetrieveBlendFactor( unsigned int options, int mask, int bitShift )
 208 {
 209   unsigned int index = options & mask;
 210   index = index >> bitShift;
 211
 212   DALI_ASSERT_DEBUG( index < BLENDING_FACTOR_COUNT );
 213
 214   return BLENDING_FACTORS[ index ];
 215 }
 216
 217 /**
 218  * Utility to retrieve one of the BlendEquation values.
 219  * @param[in] options A bitmask of blending values.
 220  * @param[in] mask The used to mask unwanted values.
 221  * @param[in] bitshift Used to shift to the correct part of options.
 222  * @return The blending equation.
 223  */
 224 BlendEquation::Type RetrieveBlendEquation( unsigned int options, int mask, int bitShift )
 225 {
 226   unsigned int index = options & mask;
 227   index = index >> bitShift;
 228
 229   DALI_ASSERT_DEBUG( index < BLENDING_EQUATION_COUNT );
 230
 231   return BLENDING_EQUATIONS[ index ];
 232 }
 233
 234 } // unnamed namespace
 235
 236 namespace Dali
 237 {
 238
 239 namespace Internal
 240 {
 241
 242 BlendingOptions::BlendingOptions()
 243 : mBitmask( 0u ),
 244   mBlendColor( NULL )
 245 {
 246   SetBlendFunc( BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA,
 247                 BlendFactor::ONE,       BlendFactor::ONE_MINUS_SRC_ALPHA );
 248
 249   SetBlendEquation( BlendEquation::ADD, BlendEquation::ADD );
 250 }
 251
 252 BlendingOptions::~BlendingOptions()
 253 {
 254   delete mBlendColor;
 255 }
 256
 257 void BlendingOptions::SetBitmask( unsigned int bitmask )
 258 {
 259   mBitmask = bitmask;
 260 }
 261
 262 unsigned int BlendingOptions::GetBitmask() const
 263 {
 264   return mBitmask;
 265 }
 266
 267 void BlendingOptions::SetBlendFunc( BlendFactor::Type srcFactorRgb,   BlendFactor::Type destFactorRgb,
 268                                     BlendFactor::Type srcFactorAlpha, BlendFactor::Type destFactorAlpha )
 269 {
 270   mBitmask &= CLEAR_BLEND_FUNC_MASK; // Clear the BlendFunc values
 271
 272   StoreBlendFactor( mBitmask, srcFactorRgb,    SHIFT_TO_SRC_FACTOR_RGB );
 273   StoreBlendFactor( mBitmask, destFactorRgb,   SHIFT_TO_DEST_FACTOR_RGB );
 274   StoreBlendFactor( mBitmask, srcFactorAlpha,  SHIFT_TO_SRC_FACTOR_ALPHA );
 275   StoreBlendFactor( mBitmask, destFactorAlpha, SHIFT_TO_DEST_FACTOR_ALPHA );
 276 }
 277
 278 BlendFactor::Type BlendingOptions::GetBlendSrcFactorRgb() const
 279 {
 280   return RetrieveBlendFactor( mBitmask, MASK_SRC_FACTOR_RGB,  SHIFT_TO_SRC_FACTOR_RGB );
 281 }
 282
 283 BlendFactor::Type BlendingOptions::GetBlendDestFactorRgb() const
 284 {
 285   return RetrieveBlendFactor( mBitmask, MASK_DEST_FACTOR_RGB, SHIFT_TO_DEST_FACTOR_RGB );
 286 }
 287
 288 BlendFactor::Type BlendingOptions::GetBlendSrcFactorAlpha() const
 289 {
 290   return RetrieveBlendFactor( mBitmask, MASK_SRC_FACTOR_ALPHA,  SHIFT_TO_SRC_FACTOR_ALPHA );
 291 }
 292
 293 BlendFactor::Type BlendingOptions::GetBlendDestFactorAlpha() const
 294 {
 295   return RetrieveBlendFactor( mBitmask, MASK_DEST_FACTOR_ALPHA, SHIFT_TO_DEST_FACTOR_ALPHA );
 296 }
 297
 298 void BlendingOptions::SetBlendEquation( BlendEquation::Type equationRgb, BlendEquation::Type equationAlpha )
 299 {
 300   mBitmask &= CLEAR_BLEND_EQUATION_MASK; // Clear the BlendEquation values
 301
 302   StoreBlendEquation( mBitmask, equationRgb,   SHIFT_TO_EQUATION_RGB );
 303   StoreBlendEquation( mBitmask, equationAlpha, SHIFT_TO_EQUATION_ALPHA );
 304 }
 305
 306 BlendEquation::Type BlendingOptions::GetBlendEquationRgb() const
 307 {
 308   return RetrieveBlendEquation( mBitmask, MASK_EQUATION_RGB, SHIFT_TO_EQUATION_RGB );
 309 }
 310
 311 BlendEquation::Type BlendingOptions::GetBlendEquationAlpha() const
 312 {
 313   return RetrieveBlendEquation( mBitmask, MASK_EQUATION_ALPHA, SHIFT_TO_EQUATION_ALPHA );
 314 }
 315
 316 void BlendingOptions::SetBlendColor( const Vector4& color )
 317 {
 318   if( Vector4::ZERO == color )
 319   {
 320     if( mBlendColor )
 321     {
 322       // Discard unnecessary vector
 323       delete mBlendColor;
 324       mBlendColor = NULL;
 325     }
 326     return;
 327   }
 328
 329   if( mBlendColor )
 330   {
 331     *mBlendColor = color;
 332   }
 333   else
 334   {
 335     // Lazy allocation when non-default is set
 336     mBlendColor = new Vector4( color );
 337   }
 338 }
 339
 340 const Vector4* BlendingOptions::GetBlendColor() const
 341 {
 342   return mBlendColor;
 343 }
 344
 345 } // namespace Internal
 346
 347 } // namespace Dali