X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Frenderers%2Fimage%2Fimage-renderer.cpp;h=b595a48d975466adbba506793d02f343a851c32f;hb=refs%2Fchanges%2F40%2F49040%2F8;hp=50fa5b8a6c2f187ceb878666bd88eddcfe5df37b;hpb=389ff4cd5d493e8eb284ec716545ddaa8b7b8f7b;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp index 50fa5b8..b595a48 100644 --- a/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp +++ b/dali-toolkit/internal/controls/renderers/image/image-renderer.cpp @@ -18,11 +18,15 @@ // CLASS HEADER #include "image-renderer.h" +// EXTERNAL HEADER +#include +#include + +// INTERNAL HEADER #include #include #include #include -#include namespace Dali { @@ -35,12 +39,31 @@ namespace Internal namespace { - -const char * const IMAGE_URL_NAME("image-url"); -const char * const IMAGE_FITTING_MODE("image-fitting-mode"); -const char * const IMAGE_SAMPLING_MODE("image-sampling-mode"); -const char * const IMAGE_DESIRED_WIDTH("image-desired-width"); -const char * const IMAGE_DESIRED_HEIGHT("image-desired-height"); +const char * const RENDERER_TYPE("renderer-type"); +const char * const RENDERER_TYPE_VALUE("image-renderer"); + +// property names +const char * const IMAGE_URL_NAME( "image-url" ); +const char * const IMAGE_FITTING_MODE( "image-fitting-mode" ); +const char * const IMAGE_SAMPLING_MODE( "image-sampling-mode" ); +const char * const IMAGE_DESIRED_WIDTH( "image-desired-width" ); +const char * const IMAGE_DESIRED_HEIGHT( "image-desired-height" ); + +// fitting modes +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("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"); std::string TEXTURE_UNIFORM_NAME = "sTexture"; @@ -72,10 +95,99 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER( }\n ); +Geometry GenerateGeometry( const Vector< Vector2 >& vertices, const Vector< unsigned int >& indices ) +{ + Property::Map vertexFormat; + vertexFormat[ "aPosition" ] = Property::VECTOR2; + PropertyBuffer vertexPropertyBuffer = PropertyBuffer::New( vertexFormat, vertices.Size() ); + if( vertices.Size() > 0 ) + { + vertexPropertyBuffer.SetData( &vertices[ 0 ] ); + } + + Property::Map indexFormat; + indexFormat[ "indices" ] = Property::INTEGER; + PropertyBuffer indexPropertyBuffer = PropertyBuffer::New( indexFormat, indices.Size() ); + if( indices.Size() > 0 ) + { + indexPropertyBuffer.SetData( &indices[ 0 ] ); + } + + // Create the geometry object + Geometry geometry = Geometry::New(); + geometry.AddVertexBuffer( vertexPropertyBuffer ); + geometry.SetIndexBuffer( indexPropertyBuffer ); + geometry.SetGeometryType( Geometry::TRIANGLE_STRIP ); + + return geometry; +} + +Geometry CreateGeometry( RendererFactoryCache& factoryCache, ImageDimensions gridSize ) +{ + Geometry geometry; + + if( gridSize == ImageDimensions( 1, 1 ) ) + { + geometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY ); + if( !geometry ) + { + geometry = factoryCache.CreateQuadGeometry(); + factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, geometry ); + } + } + else + { + uint16_t gridWidth = gridSize.GetWidth(); + uint16_t gridHeight = gridSize.GetHeight(); + + // Create vertices + Vector< Vector2 > vertices; + vertices.Reserve( ( gridWidth + 1 ) * ( gridHeight + 1 ) ); + + for( int y = 0; y < gridHeight + 1; ++y ) + { + for( int x = 0; x < gridWidth + 1; ++x ) + { + vertices.PushBack( Vector2( (float)x/gridWidth - 0.5f, (float)y/gridHeight - 0.5f) ); + } + } + + // Create indices + Vector< unsigned int > indices; + indices.Reserve( (gridWidth+2)*gridHeight*2 - 2); + + for( unsigned int row = 0u; row < gridHeight; ++row ) + { + unsigned int rowStartIndex = row*(gridWidth+1u); + unsigned int nextRowStartIndex = rowStartIndex + gridWidth +1u; + + if( row != 0u ) // degenerate index on non-first row + { + indices.PushBack( rowStartIndex ); + } + + for( unsigned int column = 0u; column < gridWidth+1u; column++) // main strip + { + indices.PushBack( rowStartIndex + column); + indices.PushBack( nextRowStartIndex + column); + } + + if( row != gridHeight-1u ) // degenerate index on non-last row + { + indices.PushBack( nextRowStartIndex + gridWidth ); + } + } + + return GenerateGeometry( vertices, indices ); + } + + return geometry; +} + } //unnamed namespace -ImageRenderer::ImageRenderer() -: ControlRenderer(), +ImageRenderer::ImageRenderer( RendererFactoryCache& factoryCache ) +: ControlRenderer( factoryCache ), mDesiredSize(), mFittingMode( FittingMode::DEFAULT ), mSamplingMode( SamplingMode::DEFAULT ) @@ -86,14 +198,17 @@ ImageRenderer::~ImageRenderer() { } -void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Property::Map& propertyMap ) +void ImageRenderer::DoInitialize( const Property::Map& propertyMap ) { - Initialize(factoryCache); - Property::Value* imageURLValue = propertyMap.Find( IMAGE_URL_NAME ); if( imageURLValue ) { imageURLValue->Get( mImageUrl ); + if( !mImageUrl.empty() ) + { + SetCachedRendererKey( mImageUrl ); + mImage.Reset(); + } Property::Value* fittingValue = propertyMap.Find( IMAGE_FITTING_MODE ); if( fittingValue ) @@ -102,23 +217,23 @@ void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Proper fittingValue->Get( fitting ); mFittingMode = FittingMode::DEFAULT; - if( fitting == "shrink-to-fit" ) + if( fitting == SHRINK_TO_FIT ) { mFittingMode = FittingMode::SHRINK_TO_FIT; } - else if( fitting == "scale-to-fill" ) + else if( fitting == SCALE_TO_FILL ) { mFittingMode = FittingMode::SCALE_TO_FILL; } - else if( fitting == "fit-width" ) + else if( fitting == FIT_WIDTH ) { mFittingMode = FittingMode::FIT_WIDTH; } - else if( fitting == "fit-height" ) + else if( fitting == FIT_HEIGHT ) { mFittingMode = FittingMode::FIT_HEIGHT; } - else if( fitting == "default" ) + else if( fitting == DEFAULT ) { mFittingMode = FittingMode::DEFAULT; } @@ -135,35 +250,35 @@ void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Proper samplingValue->Get( sampling ); mSamplingMode = SamplingMode::DEFAULT; - if( sampling == "box" ) + if( sampling == BOX ) { mSamplingMode = SamplingMode::BOX; } - else if( sampling == "nearest" ) + else if( sampling == NEAREST ) { mSamplingMode = SamplingMode::NEAREST; } - else if( sampling == "linear" ) + else if( sampling == LINEAR ) { mSamplingMode = SamplingMode::LINEAR; } - else if( sampling == "box-then-nearest" ) + else if( sampling == BOX_THEN_NEAREST ) { mSamplingMode = SamplingMode::BOX_THEN_NEAREST; } - else if( sampling == "box-then-linear" ) + else if( sampling == BOX_THEN_LINEAR ) { mSamplingMode = SamplingMode::BOX_THEN_LINEAR; } - else if( sampling == "no-filter" ) + else if( sampling == NO_FILTER ) { mSamplingMode = SamplingMode::NO_FILTER; } - else if( sampling == "dont-care" ) + else if( sampling == DONT_CARE ) { mSamplingMode = SamplingMode::DONT_CARE; } - else if( sampling == "default" ) + else if( sampling == DEFAULT ) { mSamplingMode = SamplingMode::DEFAULT; } @@ -189,25 +304,97 @@ void ImageRenderer::Initialize( RendererFactoryCache& factoryCache, const Proper mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); } - - mImage.Reset(); } void ImageRenderer::SetSize( const Vector2& size ) { ControlRenderer::SetSize( size ); - // ToDo: renderer responds to the size change +} + +void ImageRenderer::GetNaturalSize( Vector2& naturalSize ) const +{ + if(mImage) + { + naturalSize.x = mImage.GetWidth(); + naturalSize.y = mImage.GetHeight(); + return; + } + else if( mDesiredSize.GetWidth()>0 && mDesiredSize.GetHeight()>0) + { + naturalSize.x = mDesiredSize.GetWidth(); + naturalSize.y = mDesiredSize.GetHeight(); + return; + } + else if( !mImageUrl.empty() ) + { + ImageDimensions dimentions = ResourceImage::GetImageSize( mImageUrl ); + naturalSize.x = dimentions.GetWidth(); + naturalSize.y = dimentions.GetHeight(); + return; + } + + naturalSize = Vector2::ZERO; } void ImageRenderer::SetClipRect( const Rect& clipRect ) { ControlRenderer::SetClipRect( clipRect ); - //ToDo: renderer responds to the clipRect change } void ImageRenderer::SetOffset( const Vector2& offset ) { - //ToDo: renderer applies the offset +} + +void ImageRenderer::InitializeRenderer( Renderer& renderer ) +{ + Geometry geometry; + Shader shader; + if( !mImpl->mCustomShader ) + { + geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) ); + + shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); + mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader ); + } + } + else + { + geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize ); + + if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() ) + { + shader = mFactoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); + if( !shader ) + { + shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); + mFactoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, shader ); + } + } + else + { + shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? VERTEX_SHADER : mImpl->mCustomShader->mVertexShader, + mImpl->mCustomShader->mFragmentShader.empty() ? FRAGMENT_SHADER : mImpl->mCustomShader->mFragmentShader, + mImpl->mCustomShader->mHints ); + } + } + + if( !renderer ) + { + Material material = Material::New( shader ); + renderer = Renderer::New( geometry, material ); + } + else + { + renderer.SetGeometry( geometry ); + Material material = renderer.GetMaterial(); + if( material ) + { + material.SetShader( shader ); + } + } } void ImageRenderer::DoSetOnStage( Actor& actor ) @@ -229,26 +416,100 @@ void ImageRenderer::DoSetOffStage( Actor& actor ) } } -void ImageRenderer::Initialize( RendererFactoryCache& factoryCache ) +void ImageRenderer::DoCreatePropertyMap( Property::Map& map ) const { - mImpl->mGeometry = factoryCache.GetGeometry( RendererFactoryCache::QUAD_GEOMETRY ); - if( !(mImpl->mGeometry) ) + map.Clear(); + map.Insert( RENDERER_TYPE, RENDERER_TYPE_VALUE ); + if( !mImageUrl.empty() ) { - mImpl->mGeometry = factoryCache.CreateQuadGeometry(); - factoryCache.SaveGeometry( RendererFactoryCache::QUAD_GEOMETRY, mImpl->mGeometry ); + map.Insert( IMAGE_URL_NAME, mImageUrl ); + map.Insert( IMAGE_DESIRED_WIDTH, mDesiredSize.GetWidth() ); + map.Insert( IMAGE_DESIRED_HEIGHT, mDesiredSize.GetHeight() ); + } + else if( mImage ) + { + map.Insert( IMAGE_DESIRED_WIDTH, static_cast(mImage.GetWidth()) ); + map.Insert( IMAGE_DESIRED_HEIGHT, static_cast(mImage.GetHeight()) ); + + ResourceImage resourceImage = ResourceImage::DownCast(mImage); + if( resourceImage ) + { + map.Insert( IMAGE_URL_NAME, resourceImage.GetUrl() ); + } } - mImpl->mShader = factoryCache.GetShader( RendererFactoryCache::IMAGE_SHADER ); - if( !mImpl->mShader ) + switch( mFittingMode ) { - mImpl->mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); - factoryCache.SaveShader( RendererFactoryCache::IMAGE_SHADER, mImpl->mShader ); + case Dali::FittingMode::FIT_HEIGHT: + { + map.Insert( IMAGE_FITTING_MODE, FIT_HEIGHT ); + break; + } + case Dali::FittingMode::FIT_WIDTH: + { + map.Insert( IMAGE_FITTING_MODE, FIT_WIDTH ); + break; + } + case Dali::FittingMode::SCALE_TO_FILL: + { + map.Insert( IMAGE_FITTING_MODE, SCALE_TO_FILL ); + break; + } + case Dali::FittingMode::SHRINK_TO_FIT: + { + map.Insert( IMAGE_FITTING_MODE, SHRINK_TO_FIT ); + break; + } + default: + { + map.Insert( IMAGE_FITTING_MODE, DEFAULT ); + break; + } } - mDesiredSize = ImageDimensions(); - mFittingMode = FittingMode::DEFAULT; - mSamplingMode = SamplingMode::DEFAULT; - mImageUrl.clear(); + switch( mSamplingMode ) + { + case Dali::SamplingMode::BOX: + { + map.Insert( IMAGE_SAMPLING_MODE, BOX ); + break; + } + case Dali::SamplingMode::NEAREST: + { + map.Insert( IMAGE_SAMPLING_MODE, NEAREST ); + break; + } + case Dali::SamplingMode::LINEAR: + { + map.Insert( IMAGE_SAMPLING_MODE, LINEAR ); + break; + } + case Dali::SamplingMode::BOX_THEN_LINEAR: + { + map.Insert( IMAGE_SAMPLING_MODE, BOX_THEN_LINEAR ); + break; + } + case Dali::SamplingMode::BOX_THEN_NEAREST: + { + map.Insert( IMAGE_SAMPLING_MODE, BOX_THEN_NEAREST ); + break; + } + case Dali::SamplingMode::NO_FILTER: + { + map.Insert( IMAGE_SAMPLING_MODE, NO_FILTER ); + break; + } + case Dali::SamplingMode::DONT_CARE: + { + map.Insert( IMAGE_SAMPLING_MODE, DONT_CARE ); + break; + } + default: + { + map.Insert( IMAGE_SAMPLING_MODE, DEFAULT ); + break; + } + } } void ImageRenderer::SetImage( const std::string& imageUrl ) @@ -261,6 +522,7 @@ void ImageRenderer::SetImage( const std::string& imageUrl, int desiredWidth, int if( mImageUrl != imageUrl ) { mImageUrl = imageUrl; + SetCachedRendererKey( mImageUrl ); mDesiredSize = ImageDimensions( desiredWidth, desiredHeight ); mFittingMode = fittingMode; mSamplingMode = samplingMode;