const char * const IMAGE_SAMPLING_MODE( "samplingMode" );
const char * const IMAGE_DESIRED_WIDTH( "desiredWidth" );
const char * const IMAGE_DESIRED_HEIGHT( "desiredHeight" );
+const char * const IMAGE_WRAP_MODE_U("wrapModeU");
+const char * const IMAGE_WRAP_MODE_V("wrapModeV");
const char * const SYNCHRONOUS_LOADING( "synchronousLoading" );
const char * const BATCHING_ENABLED( "batchingEnabled" );
DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::SamplingMode, DONT_CARE )
DALI_ENUM_TO_STRING_TABLE_END( SAMPLING_MODE )
+// wrap modes
+DALI_ENUM_TO_STRING_TABLE_BEGIN( WRAP_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, DEFAULT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, CLAMP_TO_EDGE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, REPEAT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Dali::WrapMode, MIRRORED_REPEAT )
+DALI_ENUM_TO_STRING_TABLE_END( WRAP_MODE )
+
const std::string PIXEL_AREA_UNIFORM_NAME = "pixelArea";
+const std::string WRAP_MODE_UNIFORM_NAME = "wrapMode";
const Vector4 FULL_TEXTURE_RECT(0.f, 0.f, 1.f, 1.f);
attribute mediump vec2 aPosition;\n
uniform mediump mat4 uMvpMatrix;\n
uniform mediump vec3 uSize;\n
- uniform mediump vec4 uAtlasRect;\n
uniform mediump vec4 pixelArea;
varying mediump vec2 vTexCoord;\n
\n
vertexPosition.xyz *= uSize;\n
vertexPosition = uMvpMatrix * vertexPosition;\n
\n
- vTexCoord = mix( uAtlasRect.xy, uAtlasRect.zw, pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) ) );\n
+ vTexCoord = pixelArea.xy+pixelArea.zw*(aPosition + vec2(0.5) );\n
gl_Position = vertexPosition;\n
}\n
);
-const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
+const char* FRAGMENT_SHADER_NO_ATLAS = DALI_COMPOSE_SHADER(
varying mediump vec2 vTexCoord;\n
uniform sampler2D sTexture;\n
uniform lowp vec4 uColor;\n
}\n
);
+const char* FRAGMENT_SHADER_ATLAS_CLAMP = DALI_COMPOSE_SHADER(
+ varying mediump vec2 vTexCoord;\n
+ uniform sampler2D sTexture;\n
+ uniform mediump vec4 uAtlasRect;\n
+ uniform lowp vec4 uColor;\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;\n
+ }\n
+);
+
+const char* FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP = DALI_COMPOSE_SHADER(
+ varying mediump vec2 vTexCoord;\n
+ uniform sampler2D sTexture;\n
+ uniform mediump vec4 uAtlasRect;\n
+ // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
+ uniform lowp vec2 wrapMode;\n
+ uniform lowp vec4 uColor;\n
+ \n
+ mediump float wrapCoordinate( mediump vec2 range, mediump float coordinate, lowp float wrap )\n
+ {\n
+ mediump float coord;\n
+ if( wrap > 1.5 )\n // REFLECT
+ coord = 1.0-abs(fract(coordinate*0.5)*2.0 - 1.0);\n
+ else \n// warp == 0 or 1
+ coord = mix(coordinate, fract( coordinate ), wrap);\n
+ return clamp( mix(range.x, range.y, coord), range.x, range.y );
+ }\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;\n
+ }\n
+);
+
Geometry CreateGeometry( VisualFactoryCache& factoryCache, ImageDimensions gridSize )
{
Geometry geometry;
return geometry;
}
-} //unnamed namespace
+} // unnamed namespace
+
+ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache )
+{
+ return new ImageVisual( factoryCache );
+}
+
+ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache,
+ const std::string& imageUrl,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ Dali::SamplingMode::Type samplingMode )
+{
+ return new ImageVisual( factoryCache, imageUrl, size, fittingMode, samplingMode );
+}
+
+ImageVisualPtr ImageVisual::New( VisualFactoryCache& factoryCache, const Image& image )
+{
+ return new ImageVisual( factoryCache, image );
+}
+
+ImageVisual::ImageVisual( VisualFactoryCache& factoryCache )
+: Visual::Base( factoryCache ),
+ mImage(),
+ mPixels(),
+ mPixelArea( FULL_TEXTURE_RECT ),
+ mPlacementActor(),
+ mImageUrl(),
+ mDesiredSize(),
+ mFittingMode( FittingMode::DEFAULT ),
+ mSamplingMode( SamplingMode::DEFAULT ),
+ mWrapModeU( WrapMode::DEFAULT ),
+ mWrapModeV( WrapMode::DEFAULT ),
+ mNativeFragmentShaderCode(),
+ mNativeImageFlag( false )
+{
+}
+
+ImageVisual::ImageVisual( VisualFactoryCache& factoryCache,
+ const std::string& imageUrl,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ Dali::SamplingMode::Type samplingMode )
+: Visual::Base( factoryCache ),
+ mImage(),
+ mPixels(),
+ mPixelArea( FULL_TEXTURE_RECT ),
+ mPlacementActor(),
+ mImageUrl( imageUrl ),
+ mDesiredSize( size ),
+ mFittingMode( fittingMode ),
+ mSamplingMode( samplingMode ),
+ mWrapModeU( WrapMode::DEFAULT ),
+ mWrapModeV( WrapMode::DEFAULT ),
+ mNativeFragmentShaderCode(),
+ mNativeImageFlag( false )
+{
+}
-ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, ImageAtlasManager& atlasManager )
+ImageVisual::ImageVisual( VisualFactoryCache& factoryCache, const Image& image )
: Visual::Base( factoryCache ),
- mAtlasManager( atlasManager ),
+ mImage( image ),
+ mPixels(),
+ mPixelArea( FULL_TEXTURE_RECT ),
+ mPlacementActor(),
+ mImageUrl(),
mDesiredSize(),
mFittingMode( FittingMode::DEFAULT ),
mSamplingMode( SamplingMode::DEFAULT ),
- mNativeFragmentShaderCode( ),
+ mWrapModeU( WrapMode::DEFAULT ),
+ mWrapModeV( WrapMode::DEFAULT ),
+ mNativeFragmentShaderCode(),
mNativeImageFlag( false )
{
+ NativeImage newNativeImage = NativeImage::DownCast( image );
+ if( newNativeImage )
+ {
+ SetNativeFragmentShaderCode( newNativeImage );
+ mNativeImageFlag = true;
+ }
+ else
+ {
+ mNativeImageFlag = false;
+ }
}
ImageVisual::~ImageVisual()
desiredHeightValue->Get( desiredHeight );
}
+ Property::Value* pixelAreaValue = propertyMap.Find( Toolkit::ImageVisual::Property::PIXEL_AREA, PIXEL_AREA_UNIFORM_NAME );
+ if( pixelAreaValue )
+ {
+ pixelAreaValue->Get( mPixelArea );
+ }
+
+ Property::Value* wrapModeValueU = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_U, IMAGE_WRAP_MODE_U );
+ if( wrapModeValueU )
+ {
+ Scripting::GetEnumerationProperty( *wrapModeValueU, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, mWrapModeU );
+ }
+
+ Property::Value* wrapModeValueV = propertyMap.Find( Toolkit::ImageVisual::Property::WRAP_MODE_V, IMAGE_WRAP_MODE_V );
+ if( wrapModeValueV )
+ {
+ Scripting::GetEnumerationProperty( *wrapModeValueV, WRAP_MODE_TABLE, WRAP_MODE_TABLE_COUNT, mWrapModeV );
+ }
+
mDesiredSize = ImageDimensions( desiredWidth, desiredHeight );
}
// 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() )
+ if( imageURLValue && IsSynchronousResourceLoading() )
{
- DoSynchronousResourceLoading();
- }
-
- // remove old renderer if exit
- if( mImpl->mRenderer )
- {
- if( actor ) //remove old renderer from actor
- {
- actor.RemoveRenderer( mImpl->mRenderer );
- }
- if( !oldImageUrl.empty() ) //clean old renderer from cache
- {
- CleanCache( oldImageUrl );
- }
+ LoadResourceSynchronously();
}
NativeImage nativeImage = NativeImage::DownCast( mImage );
}
}
-void ImageVisual::SetSize( const Vector2& size )
-{
- Visual::Base::SetSize( size );
-}
-
void ImageVisual::GetNaturalSize( Vector2& naturalSize ) const
{
if(mImage)
naturalSize = Vector2::ZERO;
}
-void ImageVisual::SetClipRect( const Rect<int>& clipRect )
-{
- Visual::Base::SetClipRect( clipRect );
-}
-
-void ImageVisual::SetOffset( const Vector2& offset )
-{
-}
-
Renderer ImageVisual::CreateRenderer() const
{
Geometry geometry;
{
geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
- shader = GetImageShader(mFactoryCache);
+ shader = GetImageShader( mFactoryCache,
+ mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
+ mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE );
}
else
{
geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
{
- shader = GetImageShader(mFactoryCache);
+ shader = GetImageShader(mFactoryCache, false, true);
}
else
{
shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader,
- mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader,
+ mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER_NO_ATLAS : mImpl->mCustomShader->mFragmentShader,
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 );
}
}
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 );
}
else
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;
}
return mImpl->mFlags & Impl::IS_SYNCHRONOUS_RESOURCE_LOADING;
}
-void ImageVisual::DoSynchronousResourceLoading()
+void ImageVisual::LoadResourceSynchronously()
{
if( !mImageUrl.empty() )
{
if( !mPixels )
{
// use broken image
- return VisualFactory::GetBrokenVisualImage();
+ return VisualFactoryCache::GetBrokenVisualImage();
}
Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
image.Upload( mPixels, 0, 0 );
{
// use broken image
textureSet = TextureSet::New();
- TextureSetImage( textureSet, 0u, VisualFactory::GetBrokenVisualImage() );
+ TextureSetImage( textureSet, 0u, VisualFactoryCache::GetBrokenVisualImage() );
}
else
{
- textureSet = mAtlasManager.Add(textureRect, mPixels );
+ textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, mPixels );
+ mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
if( !textureSet ) // big image, no atlasing
{
+ mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
Atlas image = Atlas::New( mPixels.GetWidth(), mPixels.GetHeight(), mPixels.GetPixelFormat() );
image.Upload( mPixels, 0, 0 );
textureSet = TextureSet::New();
}
else
{
- textureSet = mAtlasManager.Add(textureRect, url, mDesiredSize, mFittingMode, mSamplingMode );
+ textureSet = mFactoryCache.GetAtlasManager()->Add(textureRect, url, mDesiredSize, mFittingMode, true, this );
+ mImpl->mFlags |= Impl::IS_ATLASING_APPLIED;
if( !textureSet ) // big image, no atlasing
{
+ mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
ResourceImage resourceImage = Dali::ResourceImage::New( url, mDesiredSize, mFittingMode, mSamplingMode );
resourceImage.LoadingFinishedSignal().Connect( this, &ImageVisual::OnImageLoaded );
textureSet = TextureSet::New();
}
}
+ if( !(mImpl->mFlags & Impl::IS_ATLASING_APPLIED) )
+ {
+ Sampler sampler = Sampler::New();
+ sampler.SetWrapMode( mWrapModeU, mWrapModeV );
+ textureSet.SetSampler( 0u, sampler );
+ }
+
return textureSet;
}
mImageUrl = imageUrl;
mImpl->mRenderer.Reset();
+ mImpl->mFlags &= ~Impl::IS_ATLASING_APPLIED;
if( !mImpl->mCustomShader &&
( strncasecmp( imageUrl.c_str(), HTTP_URL, sizeof(HTTP_URL) -1 ) != 0 ) && // ignore remote images
( strncasecmp( imageUrl.c_str(), HTTPS_URL, sizeof(HTTPS_URL) -1 ) != 0 ) )
{
- mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
- if( !mImpl->mRenderer )
+ bool defaultWrapMode = mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE;
+ bool cacheable = defaultWrapMode && mPixelArea == FULL_TEXTURE_RECT;
+
+ mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
+ if( cacheable ) // fetch the renderer from cache if exist
+ {
+ mImpl->mRenderer = mFactoryCache.GetRenderer( imageUrl );
+ mImpl->mFlags |= Impl::IS_FROM_CACHE;
+ }
+
+ if( !mImpl->mRenderer ) // new renderer is needed
{
Vector4 atlasRect;
TextureSet textureSet = CreateTextureSet(atlasRect, imageUrl, IsSynchronousResourceLoading() );
Geometry geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
- Shader shader( GetImageShader(mFactoryCache) );
+ Shader shader( GetImageShader(mFactoryCache, mImpl->mFlags & Impl::IS_ATLASING_APPLIED, defaultWrapMode) );
mImpl->mRenderer = Renderer::New( geometry, shader );
mImpl->mRenderer.SetTextures( textureSet );
- if( atlasRect != FULL_TEXTURE_RECT )
+
+ if( mImpl->mFlags & Impl::IS_ATLASING_APPLIED ) // the texture is packed inside atlas
{
mImpl->mRenderer.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, atlasRect );
+ if( !defaultWrapMode ) // custom wrap mode, renderer is not cached.
+ {
+ Vector2 wrapMode(mWrapModeU-WrapMode::CLAMP_TO_EDGE, mWrapModeV-WrapMode::CLAMP_TO_EDGE);
+ wrapMode.Clamp( Vector2::ZERO, Vector2( 2.f, 2.f ) );
+ mImpl->mRenderer.RegisterProperty( WRAP_MODE_UNIFORM_NAME, wrapMode );
+ }
}
- mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
- }
- mImpl->mFlags |= Impl::IS_FROM_CACHE;
+ // save the renderer to cache only when default wrap mode and default pixel area is used
+ if( cacheable )
+ {
+ mFactoryCache.SaveRenderer( imageUrl, mImpl->mRenderer );
+ }
+ }
}
else
{
// for custom shader or remote image, renderer is not cached and atlas is not applied
-
mImpl->mFlags &= ~Impl::IS_FROM_CACHE;
mImpl->mRenderer = CreateRenderer();
Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
}
}
+void ImageVisual::UploadCompleted()
+{
+ // Resource image is loaded. If weak handle is holding a placement actor, it is the time to add the renderer to actor.
+ Actor actor = mPlacementActor.GetHandle();
+ if( actor )
+ {
+ actor.AddRenderer( mImpl->mRenderer );
+ // reset the weak handle so that the renderer only get added to actor once
+ mPlacementActor.Reset();
+ }
+}
+
void ImageVisual::DoSetOnStage( Actor& actor )
{
+ mPlacementActor = actor;
+
if( !mImageUrl.empty() )
{
InitializeRenderer( mImageUrl );
{
InitializeRenderer( mImage );
}
+
+ if( mPixelArea != FULL_TEXTURE_RECT )
+ {
+ mImpl->mRenderer.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, mPixelArea );
+ }
+
+ if( IsSynchronousResourceLoading() || !(mImpl->mFlags & Impl::IS_ATLASING_APPLIED) )
+ {
+ actor.AddRenderer( mImpl->mRenderer );
+ mPlacementActor.Reset();
+ }
}
void ImageVisual::DoSetOffStage( Actor& actor )
actor.RemoveRenderer( mImpl->mRenderer );
mImpl->mRenderer.Reset();
}
+ mPlacementActor.Reset();
}
void ImageVisual::DoCreatePropertyMap( Property::Map& map ) const
map.Insert( Toolkit::ImageVisual::Property::FITTING_MODE, mFittingMode );
map.Insert( Toolkit::ImageVisual::Property::SAMPLING_MODE, mSamplingMode );
+
+ map.Insert( Toolkit::ImageVisual::Property::PIXEL_AREA, mPixelArea );
+ map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_U, mWrapModeU );
+ map.Insert( Toolkit::ImageVisual::Property::WRAP_MODE_V, mWrapModeV );
}
-Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache )
+void ImageVisual::DoSetProperty( Dali::Property::Index index, const Dali::Property::Value& propertyValue )
{
- Shader shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
- if( !shader )
- {
- shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
- factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
- shader.RegisterProperty( ATLAS_RECT_UNIFORM_NAME, FULL_TEXTURE_RECT );
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- return shader;
+ // TODO
}
-void ImageVisual::SetImage( Actor& actor, const std::string& imageUrl, ImageDimensions size, Dali::FittingMode::Type fittingMode, Dali::SamplingMode::Type samplingMode )
+Dali::Property::Value ImageVisual::DoGetProperty( Dali::Property::Index index )
{
- if( mImageUrl != imageUrl )
- {
- std::string oldImageUrl = mImageUrl;
- mImageUrl = imageUrl;
- mDesiredSize = size;
- mFittingMode = fittingMode;
- mSamplingMode = samplingMode;
- mImage.Reset();
-
- if( IsSynchronousResourceLoading() )
- {
- DoSynchronousResourceLoading();
- }
-
- if( mImpl->mRenderer )
- {
- if( GetIsFromCache() ) // if renderer is from cache, remove the old one
- {
- //remove old renderer
- if( actor )
- {
- actor.RemoveRenderer( mImpl->mRenderer );
- }
-
- //clean the cache
- if( !oldImageUrl.empty() )
- {
- CleanCache(oldImageUrl);
- }
-
- 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
- {
- Image image = LoadImage( imageUrl, IsSynchronousResourceLoading() );
- ApplyImageToSampler( image );
- }
- }
- }
+ // TODO
+ return Dali::Property::Value();
}
-void ImageVisual::SetImage( Actor& actor, const Image& image )
+Shader ImageVisual::GetImageShader( VisualFactoryCache& factoryCache, bool atlasing, bool defaultTextureWrapping )
{
- if( mImage != image )
+ Shader shader;
+ if( atlasing )
{
- NativeImage newNativeImage = NativeImage::DownCast( image );
- bool newRendererFlag = true;
-
- if( newNativeImage && !mNativeImageFlag )
- {
- SetNativeFragmentShaderCode( newNativeImage );
- }
-
- if( ( newNativeImage && mNativeImageFlag ) || ( !newNativeImage && !mNativeImageFlag ) )
+ if( defaultTextureWrapping )
{
- newRendererFlag = false;
- }
-
- if( newNativeImage )
- {
- mNativeImageFlag = true;
+ shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP );
+ if( !shader )
+ {
+ shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_CLAMP );
+ factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_DEFAULT_WRAP, shader );
+ }
}
else
{
- mNativeFragmentShaderCode.clear();
- mNativeImageFlag = false;
- }
-
- mImage = image;
-
- if( mImpl->mRenderer )
- {
- // if renderer is from cache, remove the old one, and create new renderer
- if( GetIsFromCache() )
+ shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP );
+ if( !shader )
{
- //remove old renderer
- if( actor )
- {
- actor.RemoveRenderer( mImpl->mRenderer );
- }
-
- //clean the cache
- if( !mImageUrl.empty() )
- {
- CleanCache(mImageUrl);
- }
- mImageUrl.clear();
-
- if( actor && actor.OnStage() ) // if actor on stage, create a new renderer and apply to 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 );
+ shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_ATLAS_VARIOUS_WRAP );
+ factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER_ATLAS_CUSTOM_WRAP, shader );
}
}
-
- mImageUrl.clear();
- mDesiredSize = ImageDimensions();
- mFittingMode = FittingMode::DEFAULT;
- mSamplingMode = SamplingMode::DEFAULT;
}
+ else
+ {
+ shader = factoryCache.GetShader( VisualFactoryCache::IMAGE_SHADER );
+ if( !shader )
+ {
+ shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER_NO_ATLAS );
+ factoryCache.SaveShader( VisualFactoryCache::IMAGE_SHADER, shader );
+ }
+ }
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
+ return shader;
}
void ImageVisual::ApplyImageToSampler( const Image& image )
mImpl->mRenderer.SetTextures( textureSet );
}
TextureSetImage( textureSet, 0u, image );
+ Sampler sampler = Sampler::New();
+ sampler.SetWrapMode( mWrapModeU, mWrapModeV );
+ textureSet.SetSampler( 0u, sampler );
}
}
{
if( image.GetLoadingState() == Dali::ResourceLoadingFailed )
{
- Image brokenImage = VisualFactory::GetBrokenVisualImage();
+ Image brokenImage = VisualFactoryCache::GetBrokenVisualImage();
if( mImpl->mRenderer )
{
ApplyImageToSampler( brokenImage );
void ImageVisual::CleanCache(const std::string& url)
{
- 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 );
- if( index != Property::INVALID_INDEX )
+ if( IsFromCache() )
{
- Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
- atlasRectValue.Get( atlasRect );
- }
+ TextureSet textureSet = mImpl->mRenderer.GetTextures();
- mImpl->mRenderer.Reset();
- if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
- {
- mAtlasManager.Remove( textureSet, atlasRect );
+ Vector4 atlasRect( 0.f, 0.f, 1.f, 1.f );
+ Property::Index index = mImpl->mRenderer.GetPropertyIndex( ATLAS_RECT_UNIFORM_NAME );
+ if( index != Property::INVALID_INDEX )
+ {
+ Property::Value atlasRectValue = mImpl->mRenderer.GetProperty( index );
+ atlasRectValue.Get( atlasRect );
+ }
+
+ mImpl->mRenderer.Reset();
+ if( mFactoryCache.CleanRendererCache( url ) && index != Property::INVALID_INDEX )
+ {
+ mFactoryCache.GetAtlasManager()->Remove( textureSet, atlasRect );
+ }
}
}
}
else
{
- mNativeFragmentShaderCode += FRAGMENT_SHADER;
+ mNativeFragmentShaderCode += FRAGMENT_SHADER_NO_ATLAS;
}
if( customSamplerTypename )