/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
const int MASK_SRC_FACTOR_ALPHA = 0x000000F0;
const int MASK_DEST_FACTOR_RGB = 0x00000F00;
const int MASK_DEST_FACTOR_ALPHA = 0x0000F000;
-const int MASK_EQUATION_RGB = 0x000F0000;
-const int MASK_EQUATION_ALPHA = 0x00F00000;
+const int MASK_EQUATION_RGB = 0x00FF0000;
+const int MASK_EQUATION_ALPHA = 0xFF000000;
const int SHIFT_TO_SRC_FACTOR_RGB = 0;
const int SHIFT_TO_SRC_FACTOR_ALPHA = 4;
const int SHIFT_TO_DEST_FACTOR_RGB = 8;
const int SHIFT_TO_DEST_FACTOR_ALPHA = 12;
const int SHIFT_TO_EQUATION_RGB = 16;
-const int SHIFT_TO_EQUATION_ALPHA = 20;
+const int SHIFT_TO_EQUATION_ALPHA = 24;
static unsigned int CLEAR_BLEND_FUNC_MASK = 0xFFFF0000; // Bottom 16 bits cleared
-static unsigned int CLEAR_BLEND_EQUATION_MASK = 0xFF00FFFF; // 8 bits cleared
+static unsigned int CLEAR_BLEND_EQUATION_MASK = 0x0000FFFF; // Top 16 bits cleared
/**
* Utility to store one of the BlendFunc values.
* @param[in] factor The BlendFunc value.
* @param[in] bitshift Used to shift to the correct part of options.
*/
-void StoreBlendingFactor( unsigned int& options, BlendingFactor::Type factor, int bitShift )
+void StoreBlendFactor( unsigned int& options, BlendFactor::Type factor, int bitShift )
{
- switch ( factor )
+ switch( factor )
{
- case BlendingFactor::ZERO:
+ case BlendFactor::ZERO:
+ {
options |= ( 0u << bitShift );
break;
+ }
- case BlendingFactor::ONE:
+ case BlendFactor::ONE:
+ {
options |= ( 1u << bitShift );
break;
+ }
- case BlendingFactor::SRC_COLOR:
+ case BlendFactor::SRC_COLOR:
+ {
options |= ( 2u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_SRC_COLOR:
+ case BlendFactor::ONE_MINUS_SRC_COLOR:
+ {
options |= ( 3u << bitShift );
break;
+ }
- case BlendingFactor::SRC_ALPHA:
+ case BlendFactor::SRC_ALPHA:
+ {
options |= ( 4u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_SRC_ALPHA:
+ case BlendFactor::ONE_MINUS_SRC_ALPHA:
+ {
options |= ( 5u << bitShift );
break;
+ }
- case BlendingFactor::DST_ALPHA:
+ case BlendFactor::DST_ALPHA:
+ {
options |= ( 6u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_DST_ALPHA:
+ case BlendFactor::ONE_MINUS_DST_ALPHA:
+ {
options |= ( 7u << bitShift );
break;
+ }
- case BlendingFactor::DST_COLOR:
+ case BlendFactor::DST_COLOR:
+ {
options |= ( 8u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_DST_COLOR:
+ case BlendFactor::ONE_MINUS_DST_COLOR:
+ {
options |= ( 9u << bitShift );
break;
+ }
- case BlendingFactor::SRC_ALPHA_SATURATE:
+ case BlendFactor::SRC_ALPHA_SATURATE:
+ {
options |= ( 10u << bitShift );
break;
+ }
- case BlendingFactor::CONSTANT_COLOR:
+ case BlendFactor::CONSTANT_COLOR:
+ {
options |= ( 11u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_CONSTANT_COLOR:
+ case BlendFactor::ONE_MINUS_CONSTANT_COLOR:
+ {
options |= ( 12u << bitShift );
break;
+ }
- case BlendingFactor::CONSTANT_ALPHA:
+ case BlendFactor::CONSTANT_ALPHA:
+ {
options |= ( 13u << bitShift );
break;
+ }
- case BlendingFactor::ONE_MINUS_CONSTANT_ALPHA:
+ case BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
+ {
options |= ( 14u << bitShift );
break;
+ }
}
}
* @param[in] factor The BlendEquation value.
* @param[in] bitshift Used to shift to the correct part of options.
*/
-void StoreBlendingEquation( unsigned int& options, BlendingEquation::Type factor, int bitShift )
+void StoreBlendEquation( unsigned int& options, DevelBlendEquation::Type factor, int bitShift )
{
+ // Must be same order as BLENDING_EQUATIONS, below:
+ enum {
+ ADD_BITVAL = 0u,
+ SUBTRACT_BITVAL,
+ REVERSE_SUBTRACT_BITVAL,
+ MIN_BITVAL,
+ MAX_BITVAL,
+ MULTIPLY_BITVAL,
+ SCREEN_BITVAL,
+ OVERLAY_BITVAL,
+ DARKEN_BITVAL,
+ LIGHTEN_BITVAL,
+ COLOR_DODGE_BITVAL,
+ COLOR_BURN_BITVAL,
+ HARD_LIGHT_BITVAL,
+ SOFT_LIGHT_BITVAL,
+ DIFFERENCE_BITVAL,
+ EXCLUSION_BITVAL,
+ HUE_BITVAL,
+ SATURATION_BITVAL,
+ COLOR_BITVAL,
+ LUMINOSITY_BITVAL
+ };
+
switch ( factor )
{
- case BlendingEquation::ADD:
- options |= ( 0u << bitShift );
+ case DevelBlendEquation::ADD:
+ {
+ options |= ( ADD_BITVAL << bitShift );
break;
+ }
- case BlendingEquation::SUBTRACT:
- options |= ( 1u << bitShift );
+ case DevelBlendEquation::SUBTRACT:
+ {
+ options |= ( SUBTRACT_BITVAL << bitShift );
break;
+ }
- case BlendingEquation::REVERSE_SUBTRACT:
- options |= ( 2u << bitShift );
+ case DevelBlendEquation::REVERSE_SUBTRACT:
+ {
+ options |= ( REVERSE_SUBTRACT_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::MIN:
+ {
+ options |= ( MIN_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::MAX:
+ {
+ options |= ( MAX_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::MULTIPLY:
+ {
+ options |= ( MULTIPLY_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::SCREEN:
+ {
+ options |= ( SCREEN_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::OVERLAY:
+ {
+ options |= ( OVERLAY_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::DARKEN:
+ {
+ options |= ( DARKEN_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::LIGHTEN:
+ {
+ options |= ( LIGHTEN_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::COLOR_DODGE:
+ {
+ options |= ( COLOR_DODGE_BITVAL << bitShift );
break;
+ }
+
+ case DevelBlendEquation::COLOR_BURN:
+ {
+ options |= ( COLOR_BURN_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::HARD_LIGHT:
+ {
+ options |= ( HARD_LIGHT_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::SOFT_LIGHT:
+ {
+ options |= ( SOFT_LIGHT_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::DIFFERENCE:
+ {
+ options |= ( DIFFERENCE_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::EXCLUSION:
+ {
+ options |= ( EXCLUSION_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::HUE:
+ {
+ options |= ( HUE_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::SATURATION:
+ {
+ options |= ( SATURATION_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::COLOR:
+ {
+ options |= ( COLOR_BITVAL << bitShift );
+ break;
+ }
+
+ case DevelBlendEquation::LUMINOSITY:
+ {
+ options |= ( LUMINOSITY_BITVAL << bitShift );
+ break;
+ }
}
}
const unsigned int BLENDING_FACTOR_COUNT = 15;
-const unsigned int BLENDING_EQUATION_COUNT = 3;
-
-BlendingFactor::Type BLENDING_FACTORS[ BLENDING_FACTOR_COUNT ] =
- { BlendingFactor::ZERO,
- BlendingFactor::ONE,
- BlendingFactor::SRC_COLOR,
- BlendingFactor::ONE_MINUS_SRC_COLOR,
- BlendingFactor::SRC_ALPHA,
- BlendingFactor::ONE_MINUS_SRC_ALPHA,
- BlendingFactor::DST_ALPHA,
- BlendingFactor::ONE_MINUS_DST_ALPHA,
- BlendingFactor::DST_COLOR,
- BlendingFactor::ONE_MINUS_DST_COLOR,
- BlendingFactor::SRC_ALPHA_SATURATE,
- BlendingFactor::CONSTANT_COLOR,
- BlendingFactor::ONE_MINUS_CONSTANT_COLOR,
- BlendingFactor::CONSTANT_ALPHA,
- BlendingFactor::ONE_MINUS_CONSTANT_ALPHA };
-
-BlendingEquation::Type BLENDING_EQUATIONS[ BLENDING_EQUATION_COUNT ] =
- { BlendingEquation::ADD,
- BlendingEquation::SUBTRACT,
- BlendingEquation::REVERSE_SUBTRACT };
+const unsigned int BLENDING_EQUATION_COUNT = 20;
+const unsigned int BLENDING_EQUATION_ADVANCED_INDEX_START = 5;
+const unsigned int BLENDING_EQUATION_ADVANCED_INDEX_END = 19;
+
+BlendFactor::Type BLENDING_FACTORS[ BLENDING_FACTOR_COUNT ] =
+{
+ BlendFactor::ZERO,
+ BlendFactor::ONE,
+ BlendFactor::SRC_COLOR,
+ BlendFactor::ONE_MINUS_SRC_COLOR,
+ BlendFactor::SRC_ALPHA,
+ BlendFactor::ONE_MINUS_SRC_ALPHA,
+ BlendFactor::DST_ALPHA,
+ BlendFactor::ONE_MINUS_DST_ALPHA,
+ BlendFactor::DST_COLOR,
+ BlendFactor::ONE_MINUS_DST_COLOR,
+ BlendFactor::SRC_ALPHA_SATURATE,
+ BlendFactor::CONSTANT_COLOR,
+ BlendFactor::ONE_MINUS_CONSTANT_COLOR,
+ BlendFactor::CONSTANT_ALPHA,
+ BlendFactor::ONE_MINUS_CONSTANT_ALPHA
+};
+
+DevelBlendEquation::Type BLENDING_EQUATIONS[ BLENDING_EQUATION_COUNT ] =
+{
+ DevelBlendEquation::ADD,
+ DevelBlendEquation::SUBTRACT,
+ DevelBlendEquation::REVERSE_SUBTRACT,
+ DevelBlendEquation::MIN,
+ DevelBlendEquation::MAX,
+ DevelBlendEquation::MULTIPLY,
+ DevelBlendEquation::SCREEN,
+ DevelBlendEquation::OVERLAY,
+ DevelBlendEquation::DARKEN,
+ DevelBlendEquation::LIGHTEN,
+ DevelBlendEquation::COLOR_DODGE,
+ DevelBlendEquation::COLOR_BURN,
+ DevelBlendEquation::HARD_LIGHT,
+ DevelBlendEquation::SOFT_LIGHT,
+ DevelBlendEquation::DIFFERENCE,
+ DevelBlendEquation::EXCLUSION,
+ DevelBlendEquation::HUE,
+ DevelBlendEquation::SATURATION,
+ DevelBlendEquation::COLOR,
+ DevelBlendEquation::LUMINOSITY
+};
/**
* Utility to retrieve one of the BlendFunc values.
* @param[in] bitshift Used to shift to the correct part of options.
* @return The blending factor.
*/
-BlendingFactor::Type RetrieveBlendingFactor( unsigned int options, int mask, int bitShift )
+BlendFactor::Type RetrieveBlendFactor( unsigned int options, int mask, int bitShift )
{
unsigned int index = options & mask;
index = index >> bitShift;
* @param[in] bitshift Used to shift to the correct part of options.
* @return The blending equation.
*/
-BlendingEquation::Type RetrieveBlendingEquation( unsigned int options, int mask, int bitShift )
+DevelBlendEquation::Type RetrieveBlendEquation( unsigned int options, int mask, int bitShift )
{
unsigned int index = options & mask;
index = index >> bitShift;
BlendingOptions::BlendingOptions()
: mBitmask( 0u ),
- mBlendColor( NULL )
+ mBlendColor( nullptr )
{
- SetBlendFunc( DEFAULT_BLENDING_SRC_FACTOR_RGB, DEFAULT_BLENDING_DEST_FACTOR_RGB,
- DEFAULT_BLENDING_SRC_FACTOR_ALPHA, DEFAULT_BLENDING_DEST_FACTOR_ALPHA );
+ SetBlendFunc( BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA,
+ BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA );
- SetBlendEquation( DEFAULT_BLENDING_EQUATION_RGB, DEFAULT_BLENDING_EQUATION_ALPHA );
+ SetBlendEquation( DevelBlendEquation::ADD, DevelBlendEquation::ADD );
}
-BlendingOptions::~BlendingOptions()
-{
- delete mBlendColor;
-}
+BlendingOptions::~BlendingOptions() = default;
void BlendingOptions::SetBitmask( unsigned int bitmask )
{
return mBitmask;
}
-void BlendingOptions::SetBlendFunc( BlendingFactor::Type srcFactorRgb, BlendingFactor::Type destFactorRgb,
- BlendingFactor::Type srcFactorAlpha, BlendingFactor::Type destFactorAlpha )
+void BlendingOptions::SetBlendFunc( BlendFactor::Type srcFactorRgb, BlendFactor::Type destFactorRgb,
+ BlendFactor::Type srcFactorAlpha, BlendFactor::Type destFactorAlpha )
{
mBitmask &= CLEAR_BLEND_FUNC_MASK; // Clear the BlendFunc values
- StoreBlendingFactor( mBitmask, srcFactorRgb, SHIFT_TO_SRC_FACTOR_RGB );
- StoreBlendingFactor( mBitmask, destFactorRgb, SHIFT_TO_DEST_FACTOR_RGB );
- StoreBlendingFactor( mBitmask, srcFactorAlpha, SHIFT_TO_SRC_FACTOR_ALPHA );
- StoreBlendingFactor( mBitmask, destFactorAlpha, SHIFT_TO_DEST_FACTOR_ALPHA );
+ StoreBlendFactor( mBitmask, srcFactorRgb, SHIFT_TO_SRC_FACTOR_RGB );
+ StoreBlendFactor( mBitmask, destFactorRgb, SHIFT_TO_DEST_FACTOR_RGB );
+ StoreBlendFactor( mBitmask, srcFactorAlpha, SHIFT_TO_SRC_FACTOR_ALPHA );
+ StoreBlendFactor( mBitmask, destFactorAlpha, SHIFT_TO_DEST_FACTOR_ALPHA );
}
-BlendingFactor::Type BlendingOptions::GetBlendSrcFactorRgb() const
+BlendFactor::Type BlendingOptions::GetBlendSrcFactorRgb() const
{
- return RetrieveBlendingFactor( mBitmask, MASK_SRC_FACTOR_RGB, SHIFT_TO_SRC_FACTOR_RGB );
+ return RetrieveBlendFactor( mBitmask, MASK_SRC_FACTOR_RGB, SHIFT_TO_SRC_FACTOR_RGB );
}
-BlendingFactor::Type BlendingOptions::GetBlendDestFactorRgb() const
+BlendFactor::Type BlendingOptions::GetBlendDestFactorRgb() const
{
- return RetrieveBlendingFactor( mBitmask, MASK_DEST_FACTOR_RGB, SHIFT_TO_DEST_FACTOR_RGB );
+ return RetrieveBlendFactor( mBitmask, MASK_DEST_FACTOR_RGB, SHIFT_TO_DEST_FACTOR_RGB );
}
-BlendingFactor::Type BlendingOptions::GetBlendSrcFactorAlpha() const
+BlendFactor::Type BlendingOptions::GetBlendSrcFactorAlpha() const
{
- return RetrieveBlendingFactor( mBitmask, MASK_SRC_FACTOR_ALPHA, SHIFT_TO_SRC_FACTOR_ALPHA );
+ return RetrieveBlendFactor( mBitmask, MASK_SRC_FACTOR_ALPHA, SHIFT_TO_SRC_FACTOR_ALPHA );
}
-BlendingFactor::Type BlendingOptions::GetBlendDestFactorAlpha() const
+BlendFactor::Type BlendingOptions::GetBlendDestFactorAlpha() const
{
- return RetrieveBlendingFactor( mBitmask, MASK_DEST_FACTOR_ALPHA, SHIFT_TO_DEST_FACTOR_ALPHA );
+ return RetrieveBlendFactor( mBitmask, MASK_DEST_FACTOR_ALPHA, SHIFT_TO_DEST_FACTOR_ALPHA );
}
-void BlendingOptions::SetBlendEquation( BlendingEquation::Type equationRgb, BlendingEquation::Type equationAlpha )
+void BlendingOptions::SetBlendEquation( DevelBlendEquation::Type equationRgb, DevelBlendEquation::Type equationAlpha )
{
mBitmask &= CLEAR_BLEND_EQUATION_MASK; // Clear the BlendEquation values
- StoreBlendingEquation( mBitmask, equationRgb, SHIFT_TO_EQUATION_RGB );
- StoreBlendingEquation( mBitmask, equationAlpha, SHIFT_TO_EQUATION_ALPHA );
+ StoreBlendEquation( mBitmask, equationRgb, SHIFT_TO_EQUATION_RGB );
+ StoreBlendEquation( mBitmask, equationAlpha, SHIFT_TO_EQUATION_ALPHA );
}
-BlendingEquation::Type BlendingOptions::GetBlendEquationRgb() const
+DevelBlendEquation::Type BlendingOptions::GetBlendEquationRgb() const
{
- return RetrieveBlendingEquation( mBitmask, MASK_EQUATION_RGB, SHIFT_TO_EQUATION_RGB );
+ return RetrieveBlendEquation( mBitmask, MASK_EQUATION_RGB, SHIFT_TO_EQUATION_RGB );
}
-BlendingEquation::Type BlendingOptions::GetBlendEquationAlpha() const
+DevelBlendEquation::Type BlendingOptions::GetBlendEquationAlpha() const
{
- return RetrieveBlendingEquation( mBitmask, MASK_EQUATION_ALPHA, SHIFT_TO_EQUATION_ALPHA );
+ return RetrieveBlendEquation( mBitmask, MASK_EQUATION_ALPHA, SHIFT_TO_EQUATION_ALPHA );
}
void BlendingOptions::SetBlendColor( const Vector4& color )
{
- if( Vector4::ZERO == color )
- {
- if( mBlendColor )
- {
- // Discard unnecessary vector
- delete mBlendColor;
- mBlendColor = NULL;
- }
- return;
- }
-
- if( mBlendColor )
+ if( Color::TRANSPARENT == color )
{
- *mBlendColor = color;
+ mBlendColor = nullptr;
}
else
{
- // Lazy allocation when non-default is set
- mBlendColor = new Vector4( color );
+ if( mBlendColor )
+ {
+ *mBlendColor = color;
+ }
+ else
+ {
+ // Lazy allocation when non-default is set
+ mBlendColor = new Vector4( color );
+ }
}
}
const Vector4* BlendingOptions::GetBlendColor() const
{
- return mBlendColor;
+ return mBlendColor.Get();
+}
+
+bool BlendingOptions::IsAdvancedBlendEquationApplied()
+{
+ unsigned int indexRgb = mBitmask & MASK_EQUATION_RGB;
+ indexRgb = indexRgb >> SHIFT_TO_EQUATION_RGB;
+ unsigned int indexA = mBitmask & MASK_EQUATION_ALPHA;
+ indexA = indexA >> SHIFT_TO_EQUATION_ALPHA;
+
+ return ( ( ( indexRgb >= BLENDING_EQUATION_ADVANCED_INDEX_START ) && ( indexRgb <= BLENDING_EQUATION_ADVANCED_INDEX_END ) ) ||
+ ( ( indexA >= BLENDING_EQUATION_ADVANCED_INDEX_START ) && ( indexA <= BLENDING_EQUATION_ADVANCED_INDEX_END ) ) );
+}
+
+bool BlendingOptions::IsAdvancedBlendEquationIncluded( unsigned int bitmask )
+{
+ unsigned int indexRgb = bitmask & MASK_EQUATION_RGB;
+ indexRgb = indexRgb >> SHIFT_TO_EQUATION_RGB;
+ unsigned int indexA = bitmask & MASK_EQUATION_ALPHA;
+ indexA = indexA >> SHIFT_TO_EQUATION_ALPHA;
+
+ return ( ( ( indexRgb >= BLENDING_EQUATION_ADVANCED_INDEX_START ) && ( indexRgb <= BLENDING_EQUATION_ADVANCED_INDEX_END ) ) ||
+ ( ( indexA >= BLENDING_EQUATION_ADVANCED_INDEX_START ) && ( indexA <= BLENDING_EQUATION_ADVANCED_INDEX_END ) ) );
+}
+
+bool BlendingOptions::IsAdvancedBlendEquation( DevelBlendEquation::Type equation )
+{
+ switch ( equation )
+ {
+ case DevelBlendEquation::MULTIPLY:
+ case DevelBlendEquation::SCREEN:
+ case DevelBlendEquation::OVERLAY:
+ case DevelBlendEquation::DARKEN:
+ case DevelBlendEquation::LIGHTEN:
+ case DevelBlendEquation::COLOR_DODGE:
+ case DevelBlendEquation::COLOR_BURN:
+ case DevelBlendEquation::HARD_LIGHT:
+ case DevelBlendEquation::SOFT_LIGHT:
+ case DevelBlendEquation::DIFFERENCE:
+ case DevelBlendEquation::EXCLUSION:
+ case DevelBlendEquation::HUE:
+ case DevelBlendEquation::SATURATION:
+ case DevelBlendEquation::COLOR:
+ case DevelBlendEquation::LUMINOSITY:
+ {
+ return true;
+ }
+
+ default:
+ {
+ return false;
+ }
+ }
}
} // namespace Internal