/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 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.
// load policies
DALI_ENUM_TO_STRING_TABLE_BEGIN( LOAD_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, IMMEDIATE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::LoadPolicy, ATTACHED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::LoadPolicy, IMMEDIATE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::LoadPolicy, ATTACHED )
DALI_ENUM_TO_STRING_TABLE_END( LOAD_POLICY )
// release policies
DALI_ENUM_TO_STRING_TABLE_BEGIN( RELEASE_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DETACHED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, DESTROYED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DevelImageVisual::ReleasePolicy, NEVER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, DETACHED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, DESTROYED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::Toolkit::ImageVisual::ReleasePolicy, NEVER )
DALI_ENUM_TO_STRING_TABLE_END( RELEASE_POLICY )
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
uniform sampler2D sTexture;\n
uniform lowp vec4 uColor;\n
uniform lowp vec3 mixColor;\n
- uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
- lowp vec4 visualMixColor()\n
- {\n
- return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
- }\n
void main()\n
{\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * visualMixColor();\n
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * vec4( mixColor, 1.0 );\n
}\n
);
uniform mediump vec4 uAtlasRect;\n
uniform lowp vec4 uColor;\n
uniform lowp vec3 mixColor;\n
- uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
- lowp vec4 visualMixColor()\n
- {\n
- return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
- }\n
- \n
void main()\n
{\n
mediump vec2 texCoord = clamp( mix( uAtlasRect.xy, uAtlasRect.zw, vTexCoord ), uAtlasRect.xy, uAtlasRect.zw );\n
- gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n
+ gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
}\n
);
uniform lowp vec2 wrapMode;\n
uniform lowp vec4 uColor;\n
uniform lowp vec3 mixColor;\n
- uniform lowp float opacity;\n
uniform lowp float preMultipliedAlpha;\n
\n
mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
return clamp( mix(range.x, range.y, coord), range.x, range.y );
}\n
\n
- lowp vec4 visualMixColor()\n
- {\n
- return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
- }\n
- \n
void main()\n
{\n
mediump vec2 texCoord = vec2( wrapCoordinate( uAtlasRect.xz, vTexCoord.x, wrapMode.x ),
wrapCoordinate( uAtlasRect.yw, vTexCoord.y, wrapMode.y ) );\n
- gl_FragColor = texture2D( sTexture, texCoord ) * uColor * visualMixColor();\n
+ gl_FragColor = texture2D( sTexture, texCoord ) * uColor * vec4( mixColor, 1.0 );\n
}\n
);
ImageDimensions size,
FittingMode::Type fittingMode,
Dali::SamplingMode::Type samplingMode )
-: Visual::Base( factoryCache ),
+: Visual::Base( factoryCache, Visual::FittingMode::FILL ),
mImage(),
mPixelArea( FULL_TEXTURE_RECT ),
mPlacementActor(),
mSamplingMode( samplingMode ),
mWrapModeU( WrapMode::DEFAULT ),
mWrapModeV( WrapMode::DEFAULT ),
- mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ),
- mReleasePolicy( DevelImageVisual::ReleasePolicy::DETACHED ),
+ mLoadPolicy( Toolkit::ImageVisual::LoadPolicy::ATTACHED ),
+ mReleasePolicy( Toolkit::ImageVisual::ReleasePolicy::DETACHED ),
mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ),
mAttemptAtlasing( false ),
mLoading( false ),
}
ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
-: Visual::Base( factoryCache ),
+: Visual::Base( factoryCache, Visual::FittingMode::FIT_KEEP_ASPECT_RATIO ),
mImage( image ),
mPixelArea( FULL_TEXTURE_RECT ),
mPlacementActor(),
mSamplingMode( SamplingMode::DEFAULT ),
mWrapModeU( WrapMode::DEFAULT ),
mWrapModeV( WrapMode::DEFAULT ),
- mLoadPolicy( DevelImageVisual::LoadPolicy::ATTACHED ),
- mReleasePolicy( DevelImageVisual::ReleasePolicy::DESTROYED ),
+ mLoadPolicy( Toolkit::ImageVisual::LoadPolicy::ATTACHED ),
+ mReleasePolicy( Toolkit::ImageVisual::ReleasePolicy::DESTROYED ),
mAtlasRect( 0.0f, 0.0f, 0.0f, 0.0f ),
mAttemptAtlasing( false ),
mLoading( false ),
}
// ImageVisual destroyed so remove texture unless ReleasePolicy is set to never release
- if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID ) && ( mReleasePolicy != DevelImageVisual::ReleasePolicy::NEVER ) )
+ if( ( mTextureId != TextureManager::INVALID_TEXTURE_ID ) && ( mReleasePolicy != Toolkit::ImageVisual::ReleasePolicy::NEVER ) )
{
RemoveTexture();
}
}
else if ( keyValue.first == LOAD_POLICY_NAME )
{
- DoSetProperty( Toolkit::DevelImageVisual::Property::LOAD_POLICY, keyValue.second );
+ DoSetProperty( Toolkit::ImageVisual::Property::LOAD_POLICY, keyValue.second );
}
else if( keyValue.first == RELEASE_POLICY_NAME )
{
- DoSetProperty( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, keyValue.second );
+ DoSetProperty( Toolkit::ImageVisual::Property::RELEASE_POLICY, keyValue.second );
}
else if( keyValue.first == ORIENTATION_CORRECTION_NAME )
{
- DoSetProperty( Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second );
+ DoSetProperty( Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, keyValue.second );
}
}
}
// Load image immediately if LOAD_POLICY requires it
- if ( mLoadPolicy == DevelImageVisual::LoadPolicy::IMMEDIATE )
+ if ( mLoadPolicy == Toolkit::ImageVisual::LoadPolicy::IMMEDIATE )
{
auto attemptAtlasing = AttemptAtlasing();
LoadTexture( attemptAtlasing, mAtlasRect, mTextures, mOrientationCorrection,
{
case Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING:
{
- bool sync;
+ bool sync = false;
if( value.Get( sync ) )
{
if( sync )
case Toolkit::ImageVisual::Property::DESIRED_WIDTH:
{
- float desiredWidth;
+ float desiredWidth = 0.0f;
if( value.Get( desiredWidth ) )
{
mDesiredSize.SetWidth( desiredWidth );
case Toolkit::ImageVisual::Property::DESIRED_HEIGHT:
{
- float desiredHeight;
+ float desiredHeight = 0.0f;
if( value.Get( desiredHeight ) )
{
mDesiredSize.SetHeight( desiredHeight );
case Toolkit::ImageVisual::Property::FITTING_MODE:
{
- int fittingMode;
+ int fittingMode = 0;
Scripting::GetEnumerationProperty( value, FITTING_MODE_TABLE, FITTING_MODE_TABLE_COUNT, fittingMode );
mFittingMode = Dali::FittingMode::Type( fittingMode );
break;
case Toolkit::ImageVisual::Property::SAMPLING_MODE:
{
- int samplingMode;
+ int samplingMode = 0;
Scripting::GetEnumerationProperty( value, SAMPLING_MODE_TABLE, SAMPLING_MODE_TABLE_COUNT, samplingMode );
mSamplingMode = Dali::SamplingMode::Type( samplingMode );
break;
case Toolkit::ImageVisual::Property::WRAP_MODE_U:
{
- int wrapMode;
+ int wrapMode = 0;
Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode );
mWrapModeU = Dali::WrapMode::Type( wrapMode );
break;
case Toolkit::ImageVisual::Property::WRAP_MODE_V:
{
- int wrapMode;
+ int wrapMode = 0;
Scripting::GetEnumerationProperty( value, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, wrapMode );
mWrapModeV = Dali::WrapMode::Type( wrapMode );
break;
case Toolkit::ImageVisual::Property::ALPHA_MASK_URL:
{
- std::string alphaUrl;
+ std::string alphaUrl = "";
if( value.Get( alphaUrl ) )
{
AllocateMaskData();
case Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE:
{
- float scale;
+ float scale = 1.0f;
if( value.Get( scale ) )
{
AllocateMaskData();
break;
}
- case Toolkit::DevelImageVisual::Property::RELEASE_POLICY:
+ case Toolkit::ImageVisual::Property::RELEASE_POLICY:
{
- int releasePolicy;
+ int releasePolicy = 0;
Scripting::GetEnumerationProperty( value, RELEASE_POLICY_TABLE, RELEASE_POLICY_TABLE_COUNT, releasePolicy );
- mReleasePolicy = DevelImageVisual::ReleasePolicy::Type( releasePolicy );
+ mReleasePolicy = Toolkit::ImageVisual::ReleasePolicy::Type( releasePolicy );
break;
}
- case Toolkit::DevelImageVisual::Property::LOAD_POLICY:
+ case Toolkit::ImageVisual::Property::LOAD_POLICY:
{
- int loadPolicy;
+ int loadPolicy = 0;
Scripting::GetEnumerationProperty( value, LOAD_POLICY_TABLE, LOAD_POLICY_TABLE_COUNT, loadPolicy );
- mLoadPolicy = DevelImageVisual::LoadPolicy::Type( loadPolicy );
+ mLoadPolicy = Toolkit::ImageVisual::LoadPolicy::Type( loadPolicy );
break;
}
- case Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION:
+ case Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION:
{
bool orientationCorrection( mOrientationCorrection );
if( value.Get( orientationCorrection ) )
//Register transform properties
mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
+
+ if( IsPreMultipliedAlphaEnabled() )
+ {
+ EnablePreMultipliedAlpha( true );
+ }
}
void ImageVisual::CreateNativeImageRenderer( NativeImage& nativeImage )
mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
}
-
bool ImageVisual::IsSynchronousResourceLoading() const
{
return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
atlasUploadObserver = this;
}
+ auto preMultiplyOnLoad = mFactoryCache.GetPreMultiplyOnLoad() && !mImpl->mCustomShader
+ ? TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD
+ : TextureManager::MultiplyOnLoad::LOAD_WITHOUT_MULTIPLY;
+
textures = textureManager.LoadTexture( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode,
mMaskingData, IsSynchronousResourceLoading(), mTextureId,
atlasRect, atlasing, mLoading, mWrapModeU,
mWrapModeV, textureObserver, atlasUploadObserver, atlasManager,
- mOrientationCorrection,
- forceReload );
+ mOrientationCorrection, forceReload, preMultiplyOnLoad);
+
+ if( textures && preMultiplyOnLoad == TextureManager::MultiplyOnLoad::MULTIPLY_ON_LOAD)
+ {
+ EnablePreMultipliedAlpha( true );
+ }
if( atlasing ) // Flag needs to be set before creating renderer
{
// Image release is dependent on the ReleasePolicy, renderer is destroyed.
actor.RemoveRenderer( mImpl->mRenderer);
- if( mReleasePolicy == DevelImageVisual::ReleasePolicy::DETACHED )
+ if( mReleasePolicy == Toolkit::ImageVisual::ReleasePolicy::DETACHED )
{
RemoveTexture(); // If INVALID_TEXTURE_ID then removal will be attempted on atlas
}
map.Insert( Toolkit::ImageVisual::Property::CROP_TO_MASK, mMaskingData->mCropToMask );
}
- map.Insert( Toolkit::DevelImageVisual::Property::LOAD_POLICY, mLoadPolicy );
- map.Insert( Toolkit::DevelImageVisual::Property::RELEASE_POLICY, mReleasePolicy );
- map.Insert( Toolkit::DevelImageVisual::Property::ORIENTATION_CORRECTION, mOrientationCorrection );
+ map.Insert( Toolkit::ImageVisual::Property::LOAD_POLICY, mLoadPolicy );
+ map.Insert( Toolkit::ImageVisual::Property::RELEASE_POLICY, mReleasePolicy );
+ map.Insert( Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION, mOrientationCorrection );
}
void ImageVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
// From Texture Manager
void ImageVisual::UploadComplete( bool loadingSuccess, int32_t textureId, TextureSet textureSet, bool usingAtlas,
- const Vector4& atlasRectangle )
+ const Vector4& atlasRectangle, bool preMultiplied )
{
Toolkit::Visual::ResourceStatus resourceStatus;
Actor actor = mPlacementActor.GetHandle();
{
mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, mAtlasRect );
}
+ else if( preMultiplied )
+ {
+ EnablePreMultipliedAlpha( true );
+ }
actor.AddRenderer( mImpl->mRenderer );
// reset the weak handle so that the renderer only get added to actor once