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