namespace
{
+const char * const RENDERER_TYPE("renderer-type");
+const char * const RENDERER_TYPE_VALUE("n-patch-renderer");
const char * const IMAGE_URL_NAME("image-url");
const char * const BORDER_ONLY("border-only");
/////////////////NPatchRenderer////////////////
-NPatchRenderer::NPatchRenderer()
-: ControlRenderer(),
+NPatchRenderer::NPatchRenderer( RendererFactoryCache& factoryCache )
+: ControlRenderer( factoryCache ),
mBorderOnly( false )
{
}
{
}
-void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap )
+void NPatchRenderer::DoInitialize( const Property::Map& propertyMap )
{
- Initialize(factoryCache);
-
Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME );
if( imageURLValue )
{
}
}
+void NPatchRenderer::GetNaturalSize( Vector2& naturalSize ) const
+{
+ if( mImage )
+ {
+ naturalSize.x = mImage.GetWidth();
+ naturalSize.y = mImage.GetHeight();
+ return;
+ }
+ else if( !mImageUrl.empty() )
+ {
+ ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl );
+ naturalSize.x = dimentions.GetWidth();
+ naturalSize.y = dimentions.GetHeight();
+ return;
+ }
+
+ naturalSize = Vector2::ZERO;
+}
+
void NPatchRenderer::SetClipRect( const Rect<int>& clipRect )
{
ControlRenderer::SetClipRect( clipRect );
//ToDo: renderer applies the offset
}
+void NPatchRenderer::InitializeRenderer( Renderer& renderer )
+{
+ Geometry geometry;
+ if( !mBorderOnly )
+ {
+ geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
+ if( !geometry )
+ {
+ geometry = CreateGeometry( Uint16Pair( 3, 3 ) );
+ mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, geometry );
+ }
+ }
+ else
+ {
+ geometry = mFactoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
+ if( !geometry )
+ {
+ geometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
+ mFactoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, geometry );
+ }
+ }
+
+ Shader shader = mFactoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
+ if( !shader )
+ {
+ shader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
+ mFactoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, shader );
+ }
+
+ if( !renderer )
+ {
+ Material material = Material::New( shader );
+ renderer = Renderer::New( geometry, material );
+ }
+ else
+ {
+ mImpl->mRenderer.SetGeometry( geometry );
+ Material material = mImpl->mRenderer.GetMaterial();
+ if( material )
+ {
+ material.SetShader( shader );
+ }
+ }
+}
+
void NPatchRenderer::DoSetOnStage( Actor& actor )
{
if( !mCroppedImage )
mCroppedImage.Reset();
}
-void NPatchRenderer::Initialize( RendererFactoryCache& factoryCache )
+void NPatchRenderer::DoCreatePropertyMap( Property::Map& map ) const
{
- mNinePatchGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY );
- if( !(mNinePatchGeometry) )
+ map.Clear();
+ map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE );
+ if( !mImageUrl.empty() )
{
- mNinePatchGeometry = CreateGeometry( Uint16Pair( 3, 3 ) );
- factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_GEOMETRY, mNinePatchGeometry );
+ map.Insert( IMAGE_URL_NAME, mImageUrl );
}
-
- mNinePatchBorderGeometry = factoryCache.GetGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY );
- if( !(mNinePatchBorderGeometry) )
+ else if( mImage )
{
- mNinePatchBorderGeometry = CreateGeometryBorder( Uint16Pair( 3, 3 ) );
- factoryCache.SaveGeometry( RendererFactoryCache::NINE_PATCH_BORDER_GEOMETRY, mNinePatchBorderGeometry );
+ map.Insert( IMAGE_URL_NAME, mImage.GetUrl() );
}
-
- mNinePatchShader = factoryCache.GetShader( RendererFactoryCache::NINE_PATCH_SHADER );
- if( !mNinePatchShader )
- {
- mNinePatchShader = Shader::New( VERTEX_SHADER_3X3, FRAGMENT_SHADER );
- factoryCache.SaveShader( RendererFactoryCache::NINE_PATCH_SHADER, mNinePatchShader );
- }
-
- mImpl->mGeometry = mNinePatchGeometry;
- mImpl->mShader = mNinePatchShader;
-
- mImageUrl.clear();
+ map.Insert( BORDER_ONLY, mBorderOnly );
}
void NPatchRenderer::SetImage( const std::string& imageUrl, bool borderOnly )
mStretchPixelsX = nPatch.GetStretchPixelsX();
mStretchPixelsY = nPatch.GetStretchPixelsY();
-
- if( mStretchPixelsX.Size() > 0 && mStretchPixelsY.Size() > 0 )
- {
- //only 9 patch supported for now
- mImpl->mGeometry = !mBorderOnly ? mNinePatchGeometry : mNinePatchBorderGeometry;
- mImpl->mShader = mNinePatchShader;
- }
}
void NPatchRenderer::CreateErrorImage()
mStretchPixelsX.PushBack( Uint16Pair( 0, mImageSize.GetWidth() ) );
mStretchPixelsY.Clear();
mStretchPixelsY.PushBack( Uint16Pair( 0, mImageSize.GetHeight() ) );
-
- mImpl->mGeometry = mNinePatchGeometry;
- mImpl->mShader = mNinePatchShader;
}
void NPatchRenderer::ApplyImageToSampler()