// EXTERNAL HEADER
#include <cstring> // for strncasecmp
#include <dali/public-api/images/resource-image.h>
+#include <dali/public-api/images/native-image.h>
#include <dali/integration-api/debug.h>
// INTERNAL HEADER
const std::string TEXTURE_UNIFORM_NAME = "sTexture";
const std::string ATLAS_RECT_UNIFORM_NAME = "uAtlasRect";
const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
+
+// Set this uniform to 1.0 for conventional alpha blending; if pre-multiplied alpha blending, set this uniform to 0.0
+const std::string ALPHA_BLENDING_UNIFORM_NAME = "uAlphaBlending";
+
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
+const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
+
const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
attribute mediump vec2 aPosition;\n
uniform mediump mat4 uMvpMatrix;\n
varying mediump vec2 vTexCoord;\n
uniform sampler2D sTexture;\n
uniform lowp vec4 uColor;\n
+ uniform lowp float uAlphaBlending; // Set to 1.0 for conventional alpha blending; if pre-multiplied alpha blending, set to 0.0
\n
void main()\n
{\n
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * vec4( uColor.rgb*max( uAlphaBlending, uColor.a ), uColor.a );\n
}\n
);
+
Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned int >& indices )
{
Property::Map vertexFormat;
mAtlasManager( atlasManager ),
mDesiredSize(),
mFittingMode( FittingMode::DEFAULT ),
- mSamplingMode( SamplingMode::DEFAULT )
+ mSamplingMode( SamplingMode::DEFAULT ),
+ mIsAlphaPreMultiplied( false ),
+ mNativeFragmentShaderCode( ),
+ mNativeImageFlag( false )
{
}
}
}
+ NativeImage nativeImage = NativeImage::DownCast( mImage );
+
+ if( nativeImage )
+ {
+ SetNativeFragmentShaderCode( nativeImage );
+ }
+
// if actor is on stage, create new renderer and apply to actor
if( actor && actor.OnStage() )
{
Geometry geometry;
Shader shader;
+ // If mImage is nativeImage with custom sampler or prefix, mNativeFragmentShaderCode will be applied.
+ // Renderer can't be shared between NativeImage and other image types.
+ if( !mNativeFragmentShaderCode.empty() )
+ {
+ return CreateNativeImageRenderer();
+ }
+
if( !mImpl->mCustomShader )
{
geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
shader = GetImageShader(mFactoryCache);
}
else
{
shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f );
+ }
+ }
+ }
+
+ Material material = Material::New( shader );
+ return Renderer::New( geometry, material );
+}
+
+Renderer ImageRenderer::CreateNativeImageRenderer() const
+{
+ Geometry geometry;
+ Shader shader;
+
+ if( !mImpl->mCustomShader )
+ {
+ geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+
+ shader = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f );
+ }
+ else
+ {
+ geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+ if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+ {
+ shader = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+ }
+ else
+ {
+ shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
+ mNativeFragmentShaderCode,
+ mImpl->mCustomShader->mHints );
+ if( mImpl->mCustomShader->mVertexShader.empty() )
+ {
+ shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f );
}
}
}
{
InitializeRenderer( mImage );
}
+
+ EnablePreMultipliedAlpha( mIsAlphaPreMultiplied );
}
void ImageRenderer::DoSetOffStage( Actor& actor )
factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader );
shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ shader.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 1.f );
}
return shader;
}
{
if( mImage != image )
{
+ NativeImage newNativeImage = NativeImage::DownCast( image );
+ bool newRendererFlag = true;
+
+ if( newNativeImage && !mNativeImageFlag )
+ {
+ SetNativeFragmentShaderCode( newNativeImage );
+ }
+
+ if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
+ {
+ newRendererFlag = false;
+ }
+
+ if( newNativeImage )
+ {
+ mNativeImageFlag = true;
+ }
+ else
+ {
+ mNativeFragmentShaderCode.clear();
+ mNativeImageFlag = false;
+ }
+
mImage = image;
if( mImpl->mRenderer )
{
- if( GetIsFromCache() ) // if renderer is from cache, remove the old one
+ // if renderer is from cache, remove the old one, and create new renderer
+ if( GetIsFromCache() )
{
//remove old renderer
if( actor )
SetOnStage(actor);
}
}
+ // if input image is nativeImage and mImage is regular image or the reverse, remove the old one, and create new renderer
+ else if( newRendererFlag )
+ {
+ //remove old renderer
+ if( actor )
+ {
+ actor.RemoveRenderer( mImpl->mRenderer );
+ }
+
+ if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to actor
+ {
+ SetOnStage(actor);
+ }
+ }
else // if renderer is not from cache, reuse the same renderer and only change the texture
{
ApplyImageToSampler( image );
}
}
+void ImageRenderer::EnablePreMultipliedAlpha( bool preMultipled )
+{
+ mIsAlphaPreMultiplied = preMultipled;
+ if( mImpl->mRenderer )
+ {
+ Material material = mImpl->mRenderer.GetMaterial();
+
+ if( preMultipled )
+ {
+ material.SetBlendFunc( BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA,
+ BlendingFactor::ONE, BlendingFactor::ONE );
+ if( !mImpl->mCustomShader || mImpl->mCustomShader->mVertexShader.empty())
+ {
+ material.RegisterProperty( ALPHA_BLENDING_UNIFORM_NAME, 0.f );
+ }
+ }
+ else
+ {
+ // using default blend func
+ material.SetBlendFunc( BlendingFactor::SRC_ALPHA, BlendingFactor::ONE_MINUS_SRC_ALPHA,
+ BlendingFactor::ONE, BlendingFactor::ONE_MINUS_SRC_ALPHA );
+
+ Property::Index index = material.GetPropertyIndex( ALPHA_BLENDING_UNIFORM_NAME );
+ if( index != Property::INVALID_INDEX ) // only set value when the property already exist on the Material
+ {
+ material.SetProperty( index, 1.f );
+ }
+ }
+ }
+}
+
void ImageRenderer::ApplyImageToSampler( const Image& image )
{
if( image )
}
}
+void ImageRenderer::SetNativeFragmentShaderCode( Dali::NativeImage& nativeImage )
+{
+ const char* fragmentPreFix = nativeImage.GetCustomFragmentPreFix();
+ const char* customSamplerTypename = nativeImage.GetCustomSamplerTypename();
+
+ if( fragmentPreFix )
+ {
+ mNativeFragmentShaderCode = fragmentPreFix;
+ mNativeFragmentShaderCode += "\n";
+ }
+
+ if( mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty() )
+ {
+ mNativeFragmentShaderCode += mImpl->mCustomShader->mFragmentShader;
+ }
+ else
+ {
+ mNativeFragmentShaderCode += FRAGMENT_SHADER;
+ }
+
+ if( customSamplerTypename )
+ {
+ mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
+ }
+
+}
+
} // namespace Internal
} // namespace Toolkit
projects / platform / core / uifw / dali-toolkit.git / blobdiff