/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 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.
#include <cstring> // for strncasecmp
#include <dali/public-api/images/resource-image.h>
#include <dali/public-api/images/native-image.h>
+#include <dali/devel-api/images/atlas.h>
+#include <dali/devel-api/images/texture-set-image.h>
+#include <dali/devel-api/adaptor-framework/bitmap-loader.h>
#include <dali/integration-api/debug.h>
// INTERNAL HEADER
+#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
#include <dali-toolkit/internal/controls/renderers/renderer-factory-impl.h>
#include <dali-toolkit/internal/controls/renderers/renderer-factory-cache.h>
#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
const char HTTP_URL[] = "http://";
const char HTTPS_URL[] = "https://";
-const char * const RENDERER_TYPE("rendererType");
-const char * const RENDERER_TYPE_VALUE("image");
-
// property names
-const char * const IMAGE_URL_NAME( "imageUrl" );
-const char * const IMAGE_FITTING_MODE( "imageFittingMode" );
-const char * const IMAGE_SAMPLING_MODE( "imageSamplingMode" );
-const char * const IMAGE_DESIRED_WIDTH( "imageDesiredWidth" );
-const char * const IMAGE_DESIRED_HEIGHT( "imageDesiredHeight" );
+const char * const IMAGE_FITTING_MODE( "fittingMode" );
+const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
+const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
+const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
+const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
// fitting modes
-const char * const SHRINK_TO_FIT("shrinkToFit");
-const char * const SCALE_TO_FILL("scaleToFill");
-const char * const FIT_WIDTH("fitWidth");
-const char * const FIT_HEIGHT("fitHeight");
-const char * const DEFAULT("default");
+const char * const SHRINK_TO_FIT("SHRINK_TO_FIT");
+const char * const SCALE_TO_FILL("SCALE_TO_FILL");
+const char * const FIT_WIDTH("FIT_WIDTH");
+const char * const FIT_HEIGHT("FIT_HEIGHT");
+const char * const DEFAULT("DEFAULT");
// sampling modes
-const char * const BOX("box");
-const char * const NEAREST("nearest");
-const char * const LINEAR("linear");
-const char * const BOX_THEN_NEAREST("boxThenNearest");
-const char * const BOX_THEN_LINEAR("boxThenLinear");
-const char * const NO_FILTER("noFilter");
-const char * const DONT_CARE("dontCare");
-
-const std::string TEXTURE_UNIFORM_NAME = "sTexture";
-const std::string ATLAS_RECT_UNIFORM_NAME = "uAtlasRect";
+const char * const BOX("BOX");
+const char * const NEAREST("NEAREST");
+const char * const LINEAR("LINEAR");
+const char * const BOX_THEN_NEAREST("BOX_THEN_NEAREST");
+const char * const BOX_THEN_LINEAR("BOX_THEN_LINEAR");
+const char * const NO_FILTER("NO_FILTER");
+const char * const DONT_CARE("DONT_CARE");
+
const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
}
mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
+
+ }
+
+ Property::Value* syncLoading = propertyMap.Find( SYNCHRONOUS_LOADING );
+ if( syncLoading )
+ {
+ bool sync;
+ syncLoading->Get( sync );
+ if( sync )
+ {
+ mImpl->mFlags |= Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+ }
+ else
+ {
+ mImpl->mFlags &= ~Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+ }
+ }
+
+ // if sync loading is required, the loading should start immediately when new image url is set or the actor is off stage
+ // ( for on-stage actor with image url unchanged, resource loading is already finished)
+ if( ( !mImpl->mRenderer || imageURLValue) && IsSynchronousResourceLoading() )
+ {
+ DoSynchronousResourceLoading();
}
// remove old renderer if exit
}
}
- Material material = Material::New( shader );
- return Renderer::New( geometry, material );
+ Renderer renderer = Renderer::New( geometry, shader );
+
+ return renderer;
}
Renderer ImageRenderer::CreateNativeImageRenderer() const
else
{
geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
- if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
+ 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 );
+ }
+ }
+
+ TextureSet textureSet = TextureSet::New();
+ Renderer renderer = Renderer::New( geometry, shader );
+ renderer.SetTextures( textureSet );
+
+ return renderer;
+}
+
+
+bool ImageRenderer::IsSynchronousResourceLoading() const
+{
+ return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
+}
+
+void ImageRenderer::DoSynchronousResourceLoading()
+{
+ if( !mImageUrl.empty() )
+ {
+ BitmapLoader loader = BitmapLoader::New( mImageUrl, mDesiredSize, mFittingMode, mSamplingMode );
+ loader.Load();
+ mPixels = loader.GetPixelData();
+ }
+}
+
+Image ImageRenderer::LoadImage( const std::string& url, bool synchronousLoading )
+{
+ if( synchronousLoading )
+ {
+ if( !mPixels )
{
- shader = Shader::New( VERTEX_SHADER, mNativeFragmentShaderCode );
+ // use broken image
+ return RendererFactory::GetBrokenRendererImage();
+ }
+ Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
+ image.Upload( mPixels, 0, 0 );
+ return image;
+ }
+ else
+ {
+ ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
+ resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ return resourceImage;
+ }
+}
+
+TextureSet ImageRenderer::CreateTextureSet( Vector4& textureRect, const std::string& url, bool synchronousLoading )
+{
+ TextureSet textureSet;
+ textureRect = FULL_TEXTURE_RECT;
+ if( synchronousLoading )
+ {
+ if( !mPixels )
+ {
+ // use broken image
+ textureSet = TextureSet::New();
+ TextureSetImage( textureSet, 0u, RendererFactory::GetBrokenRendererImage() );
}
else
{
- shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
- mNativeFragmentShaderCode,
- mImpl->mCustomShader->mHints );
- if( mImpl->mCustomShader->mVertexShader.empty() )
+ textureSet = mAtlasManager.Add(textureRect, mPixels );
+ if( !textureSet ) // big image, no atlasing
{
- shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
+ image.Upload( mPixels, 0, 0 );
+ textureSet = TextureSet::New();
+ TextureSetImage( textureSet, 0u, image );
}
}
}
+ else
+ {
+ textureSet = mAtlasManager.Add(textureRect, url, mDesiredSize, mFittingMode, mSamplingMode );
+ if( !textureSet ) // big image, no atlasing
+ {
+ ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
+ resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ textureSet = TextureSet::New();
+ TextureSetImage( textureSet, 0u, resourceImage );
+ }
+ }
- Material material = Material::New( shader );
- return Renderer::New( geometry, material );
+ return textureSet;
}
void ImageRenderer::InitializeRenderer( const std::string& imageUrl )
if( !mImpl->mRenderer )
{
Vector4 atlasRect;
- Material material = mAtlasManager.Add(atlasRect, imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- if( material )
+ TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
+ Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
+ Shader shader( GetImageShader(mFactoryCache) );
+ mImpl->mRenderer = Renderer::New( geometry, shader );
+ mImpl->mRenderer.SetTextures( textureSet );
+ if( atlasRect != FULL_TEXTURE_RECT )
{
- Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
- mImpl->mRenderer = Renderer::New( geometry, material );
mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
}
- else // big image, atlasing is not applied
- {
- mImpl->mRenderer = CreateRenderer();
-
- ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- Material material = mImpl->mRenderer.GetMaterial();
- material.AddTexture( image, TEXTURE_UNIFORM_NAME );
- }
-
mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
}
mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
mImpl->mRenderer = CreateRenderer();
- ResourceImage resourceImage = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- resourceImage.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
- ApplyImageToSampler( resourceImage );
+ Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
+ ApplyImageToSampler( image );
}
}
void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
+ map.Insert( RENDERER_TYPE, IMAGE_RENDERER );
+
+ bool sync = IsSynchronousResourceLoading();
+ map.Insert( SYNCHRONOUS_LOADING, sync );
if( !mImageUrl.empty() )
{
map.Insert( IMAGE_URL_NAME, mImageUrl );
mSamplingMode = samplingMode;
mImage.Reset();
+ if( IsSynchronousResourceLoading() )
+ {
+ DoSynchronousResourceLoading();
+ }
+
if( mImpl->mRenderer )
{
if( GetIsFromCache() ) // if renderer is from cache, remove the old one
}
else // if renderer is not from cache, reuse the same renderer and only change the texture
{
- ResourceImage image = Dali::ResourceImage::New( imageUrl, mDesiredSize, mFittingMode, mSamplingMode );
- image.LoadingFinishedSignal().Connect( this, &ImageRenderer::OnImageLoaded );
+ Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
ApplyImageToSampler( image );
}
}
{
if( image )
{
- Material material = mImpl->mRenderer.GetMaterial();
- if( material )
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
+ if( !textureSet )
{
- int index = material.GetTextureIndex( TEXTURE_UNIFORM_NAME );
- if( index != -1 )
- {
- material.SetTextureImage( index, image );
- return;
- }
-
- material.AddTexture( image, TEXTURE_UNIFORM_NAME );
+ textureSet = TextureSet::New();
+ mImpl->mRenderer.SetTextures( textureSet );
}
+ TextureSetImage( textureSet, 0u, image );
}
}
void ImageRenderer::CleanCache(const std::string& url)
{
- Material material = mImpl->mRenderer.GetMaterial();
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
mImpl->mRenderer.Reset();
if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
{
- mAtlasManager.Remove( material, atlasRect );
+ mAtlasManager.Remove( textureSet, atlasRect );
}
}
{
mNativeFragmentShaderCode.replace( mNativeFragmentShaderCode.find( DEFAULT_SAMPLER_TYPENAME ), strlen( DEFAULT_SAMPLER_TYPENAME ), customSamplerTypename );
}
-
}
} // namespace Internal
projects / platform / core / uifw / dali-toolkit.git / blobdiff