Property::Map propertyMap;
propertyMap.Insert("rendererType", "color");
propertyMap.Insert("mixColor", Color::BLUE);
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
ControlRenderer controlRendererCopy( controlRenderer );
DALI_TEST_CHECK(controlRenderer == controlRendererCopy);
Property::Map propertyMap;
propertyMap.Insert("rendererType", "color");
propertyMap.Insert("mixColor", Color::BLUE);
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
controlRenderer.SetDepthIndex( 1.f );
Vector2 naturalSize;
// color renderer
- ControlRenderer colorRenderer = factory.GetControlRenderer( Color::MAGENTA );
+ Dali::Property::Map map;
+ map[ "rendererType" ] = "color";
+ map[ "mixColor" ] = Color::MAGENTA;
+ ControlRenderer colorRenderer = factory.CreateControlRenderer( map );
colorRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( colorRenderer.GetSize(), rendererSize, TEST_LOCATION );
colorRenderer.GetNaturalSize(naturalSize);
// image renderer
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
- ControlRenderer imageRenderer = factory.GetControlRenderer( image );
+ ControlRenderer imageRenderer = factory.CreateControlRenderer( image );
imageRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( imageRenderer.GetSize(), rendererSize, TEST_LOCATION );
imageRenderer.GetNaturalSize(naturalSize);
Vector2 testSize(80.f, 160.f);
platform.SetClosestImageSize(testSize);
image = ResourceImage::New(TEST_NPATCH_FILE_NAME);
- ControlRenderer nPatchRenderer = factory.GetControlRenderer( image );
+ ControlRenderer nPatchRenderer = factory.CreateControlRenderer( image );
nPatchRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( nPatchRenderer.GetSize(), rendererSize, TEST_LOCATION );
nPatchRenderer.GetNaturalSize(naturalSize);
// border renderer
float borderSize = 5.f;
- ControlRenderer borderRenderer = factory.GetControlRenderer( borderSize, Color::RED );
+ map.Clear();
+ map[ "rendererType" ] = "border";
+ map[ "borderColor" ] = Color::RED;
+ map[ "borderSize" ] = borderSize;
+ ControlRenderer borderRenderer = factory.CreateControlRenderer( map );
borderRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( borderRenderer.GetSize(), rendererSize, TEST_LOCATION );
borderRenderer.GetNaturalSize(naturalSize);
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer gradientRenderer = factory.CreateControlRenderer(propertyMap);
gradientRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( gradientRenderer.GetSize(), rendererSize, TEST_LOCATION );
gradientRenderer.GetNaturalSize(naturalSize);
DALI_TEST_EQUALS( naturalSize, Vector2::ZERO,TEST_LOCATION );
//svg renderer
- ControlRenderer svgRenderer = factory.GetControlRenderer( TEST_SVG_FILE_NAME );
+ ControlRenderer svgRenderer = factory.CreateControlRenderer( TEST_SVG_FILE_NAME, ImageDimensions() );
svgRenderer.SetSize( rendererSize );
DALI_TEST_EQUALS( svgRenderer.GetSize(), rendererSize, TEST_LOCATION );
svgRenderer.GetNaturalSize(naturalSize);
Property::Map propertyMap;
propertyMap.Insert("rendererType", "color");
propertyMap.Insert("mixColor", Color::BLUE);
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
Actor actor = Actor::New();
actor.SetSize(200.f, 200.f);
}
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
- imageRenderer = factory.GetControlRenderer(image);
+ imageRenderer = factory.CreateControlRenderer(image);
DALI_TEST_CHECK( imageRenderer );
imageRenderer.SetOnStage( actor );
Property::Map propertyMap;
propertyMap.Insert("rendererType", "color");
propertyMap.Insert("mixColor", Color::BLUE);
- ControlRenderer colorRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer colorRenderer = factory.CreateControlRenderer( propertyMap );
Property::Map resultMap;
colorRenderer.CreatePropertyMap( resultMap );
// change the blend color
Actor actor;
- factory.ResetRenderer( colorRenderer, actor, Color::CYAN );
+ colorRenderer.RemoveAndReset( actor );
+ propertyMap["mixColor"] = Color::CYAN;
+ colorRenderer = factory.CreateControlRenderer( propertyMap );
colorRenderer.CreatePropertyMap( resultMap );
colorValue = resultMap.Find( "mixColor", Property::VECTOR4 );
propertyMap.Insert("rendererType", "border");
propertyMap.Insert("borderColor", Color::BLUE);
propertyMap.Insert("borderSize", 5.f);
- ControlRenderer borderRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer borderRenderer = factory.CreateControlRenderer( propertyMap );
Property::Map resultMap;
borderRenderer.CreatePropertyMap( resultMap );
DALI_TEST_CHECK( sizeValue );
DALI_TEST_CHECK( sizeValue->Get<float>() == 5.f );
- borderRenderer = factory.GetControlRenderer( 10.f, Color::CYAN );
+ Property::Map propertyMap1;
+ propertyMap1[ "rendererType" ] = "border";
+ propertyMap1[ "borderColor" ] = Color::CYAN;
+ propertyMap1[ "borderSize" ] = 10.0f;
+ borderRenderer = factory.CreateControlRenderer( propertyMap1 );
borderRenderer.CreatePropertyMap( resultMap );
typeValue = resultMap.Find( "rendererType", Property::STRING );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer gradientRenderer = factory.CreateControlRenderer(propertyMap);
Property::Map resultMap;
gradientRenderer.CreatePropertyMap( resultMap );
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer gradientRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( gradientRenderer );
Property::Map resultMap;
propertyMap.Insert( "samplingMode", "BOX_THEN_NEAREST" );
propertyMap.Insert( "synchronousLoading", true );
- ControlRenderer imageRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer imageRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( imageRenderer );
Property::Map resultMap;
// Get an image renderer with an image handle, and test the default property values
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME, ImageDimensions(100, 200));
- imageRenderer = factory.GetControlRenderer(image);
+ imageRenderer = factory.CreateControlRenderer(image);
imageRenderer.CreatePropertyMap( resultMap );
value = resultMap.Find( "rendererType", Property::STRING );
propertyMap.Insert( "rendererType", "image" );
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
propertyMap.Insert( "borderOnly", true );
- ControlRenderer nPatchRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer nPatchRenderer = factory.CreateControlRenderer( propertyMap );
Property::Map resultMap;
nPatchRenderer.CreatePropertyMap( resultMap );
Property::Map propertyMap;
propertyMap.Insert( "rendererType", "image" );
propertyMap.Insert( "url", TEST_SVG_FILE_NAME );
- ControlRenderer svgRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer svgRenderer = factory.CreateControlRenderer( propertyMap );
Property::Map resultMap;
svgRenderer.CreatePropertyMap( resultMap );
DALI_TEST_CHECK( value->Get<std::string>() == TEST_SVG_FILE_NAME );
// request SvgRenderer with an URL
- ControlRenderer svgRenderer2 = factory.GetControlRenderer( TEST_SVG_FILE_NAME );
+ ControlRenderer svgRenderer2 = factory.CreateControlRenderer( TEST_SVG_FILE_NAME, ImageDimensions() );
resultMap.Clear();
svgRenderer2.CreatePropertyMap( resultMap );
// check the property values from the returned map from control renderer
propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
propertyMap.Insert( "texturesPath", TEST_RESOURCE_LOCATION );
propertyMap.Insert( "shaderType", "textureless" );
- ControlRenderer meshRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer meshRenderer = factory.CreateControlRenderer( propertyMap );
Property::Map resultMap;
meshRenderer.CreatePropertyMap( resultMap );
Property::Map propertyMap1;
propertyMap1.Insert("rendererType", "color");
propertyMap1.Insert("mixColor", Color::BLUE);
- ControlRenderer colorRenderer = factory.GetControlRenderer(propertyMap1);
+ ControlRenderer colorRenderer = factory.CreateControlRenderer(propertyMap1);
DALI_TEST_CHECK( colorRenderer );
DALI_TEST_CHECK( IsDebugRenderer( colorRenderer ) );
propertyMap2.Insert("rendererType", "border");
propertyMap2.Insert("borderColor", Color::BLUE);
propertyMap2.Insert("borderSize", 2.f);
- ControlRenderer borderRenderer = factory.GetControlRenderer(propertyMap2);
+ ControlRenderer borderRenderer = factory.CreateControlRenderer(propertyMap2);
DALI_TEST_CHECK( borderRenderer );
DALI_TEST_CHECK( IsDebugRenderer( borderRenderer ) );
stopColors.PushBack( Color::RED );
stopColors.PushBack( Color::GREEN );
propertyMap3.Insert("gradientStopColor", stopColors);
- ControlRenderer gradientRenderer = factory.GetControlRenderer(propertyMap3);
+ ControlRenderer gradientRenderer = factory.CreateControlRenderer(propertyMap3);
DALI_TEST_CHECK( gradientRenderer );
DALI_TEST_CHECK( IsDebugRenderer( gradientRenderer ) );
Property::Map propertyMap4;
propertyMap4.Insert( "rendererType", "image" );
propertyMap4.Insert( "url", TEST_IMAGE_FILE_NAME );
- ControlRenderer imageRenderer = factory.GetControlRenderer( propertyMap4 );
+ ControlRenderer imageRenderer = factory.CreateControlRenderer( propertyMap4 );
DALI_TEST_CHECK( imageRenderer );
DALI_TEST_CHECK( IsDebugRenderer( imageRenderer ) );
Property::Map propertyMap5;
propertyMap5.Insert( "rendererType", "image" );
propertyMap5.Insert( "url", TEST_NPATCH_FILE_NAME );
- ControlRenderer nPatchRenderer = factory.GetControlRenderer( propertyMap4 );
+ ControlRenderer nPatchRenderer = factory.CreateControlRenderer( propertyMap4 );
DALI_TEST_CHECK( nPatchRenderer );
DALI_TEST_CHECK( IsDebugRenderer( nPatchRenderer ) );
DALI_TEST_CHECK( factory );
// Test that color renderer is replaced with debug renderer
- ControlRenderer colorRenderer = factory.GetControlRenderer(Color::CYAN);
+ Dali::Property::Map map;
+ map[ "rendererType" ] = "color";
+ map[ "mixColor" ] = Color::CYAN;
+
+ ControlRenderer colorRenderer = factory.CreateControlRenderer( map);
DALI_TEST_CHECK( colorRenderer );
DALI_TEST_CHECK( IsDebugRenderer( colorRenderer ) );
// Test that border renderer is replaced with debug renderer
- ControlRenderer borderRenderer = factory.GetControlRenderer(2.f, Color::GREEN);
+ map.Clear();
+ map[ "rendererType" ] = "border";
+ map[ "borderColor" ] = Color::GREEN;
+ map[ "borderSize" ] = 2.f;
+ ControlRenderer borderRenderer = factory.CreateControlRenderer( map );
DALI_TEST_CHECK( borderRenderer );
DALI_TEST_CHECK( IsDebugRenderer( borderRenderer ) );
// Test that image renderer is replaced with debug renderer
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- ControlRenderer imageRenderer = factory.GetControlRenderer( image );
+ ControlRenderer imageRenderer = factory.CreateControlRenderer( image );
DALI_TEST_CHECK( imageRenderer );
DALI_TEST_CHECK( IsDebugRenderer( imageRenderer ) );
// Test that n patch renderer is replaced with debug renderer
- ControlRenderer nPatchRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
+ ControlRenderer nPatchRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( nPatchRenderer );
DALI_TEST_CHECK( IsDebugRenderer( nPatchRenderer ) );
EnvironmentVariable::SetTestingEnvironmentVariable(false);
END_TEST;
}
-
-int UtcDaliDebugRendererResetRenderer(void)
-{
- EnvironmentVariable::SetTestingEnvironmentVariable(true);
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliDebugRendererResetRenderer: Reset renderer with various parameters" );
-
- RendererFactory factory = RendererFactory::Get();
- DALI_TEST_CHECK( factory );
-
- // Test that color renderer is replaced with debug renderer
- ControlRenderer controlRenderer = factory.GetControlRenderer(Color::CYAN);
- DALI_TEST_CHECK( controlRenderer );
- DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
-
- Actor actor;
- // Reset to render another color
- // Test that color renderer is replaced with debug renderer
- factory.ResetRenderer( controlRenderer, actor, Color::BLUE );
- DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
-
- // Reset to render an image
- // Test that image renderer is replaced with debug renderer
- Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- factory.ResetRenderer( controlRenderer, actor, image );
- DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
-
- // Reset with a property map of border renderer
- // Test that border renderer is replaced with debug renderer
- Property::Map propertyMap;
- propertyMap.Insert("rendererType", "border");
- propertyMap.Insert("borderColor", Color::BLUE);
- propertyMap.Insert("borderSize", 2.f);
- factory.ResetRenderer( controlRenderer, actor, propertyMap );
- DALI_TEST_CHECK( IsDebugRenderer( controlRenderer ) );
-
- EnvironmentVariable::SetTestingEnvironmentVariable(false);
- END_TEST;
-}
// Sync loading, no atlasing for big size image
{
- ImageView imageView = ImageView::New( gImage_600_RGB );
+ ImageView imageView = ImageView::New();
// Sync loading is used
+ syncLoadingMap[ "url" ] = gImage_600_RGB;
imageView.SetProperty( ImageView::Property::IMAGE, syncLoadingMap );
// BitmapLoader is used, and the loading is started immediately even the actor is not on stage.
customShader.Insert( "hints", shaderHints );
Property::Map map;
- map.Insert( "rendererType", "image" );
map.Insert( "shader", customShader );
TestNativeImagePointer nativeImageInterface = TestNativeImage::New( width, height );
imageView.SetProperty( ImageView::Property::IMAGE, map );
Stage::GetCurrent().Add( imageView );
- imageView.SetProperty( ImageView::Property::IMAGE, map );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
gl.EnableTextureCallTrace( true );
customShader.Insert( "hints", shaderHints );
Property::Map map;
- map.Insert( "rendererType", "image" );
map.Insert( "shader", customShader );
BufferImage image = CreateBufferImage( width, height, Color::WHITE );
imageView.SetProperty( ImageView::Property::IMAGE, map );
Stage::GetCurrent().Add( imageView );
- imageView.SetProperty( ImageView::Property::IMAGE, map );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
gl.EnableTextureCallTrace( true );
propertyMap.Insert("rendererType", "color");
propertyMap.Insert("mixColor", testColor);
- ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
DALI_TEST_CHECK( factory );
Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
- ControlRenderer controlRenderer = factory.GetControlRenderer(testColor);
+ Dali::Property::Map map;
+ map[ "rendererType" ] = "color";
+ map[ "mixColor" ] = testColor;
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( map );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert("borderColor", testColor);
propertyMap.Insert("borderSize", testSize);
- ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
float testSize = 5.f;
- ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor );
+ Dali::Property::Map propertyMap;
+ propertyMap[ "rendererType" ] = "border";
+ propertyMap[ "borderColor" ] = testColor;
+ propertyMap[ "borderSize" ] = testSize;
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
controlRenderer.SetOffStage( actor );
// enable the anti-aliasing
- controlRenderer = factory.GetControlRenderer(testSize, testColor, true );
+ Dali::Property::Map map;
+ map[ "rendererType" ] = "border";
+ map[ "borderColor" ] = testColor;
+ map[ "borderSize" ] = testSize;
+ map[ "antiAliasing" ] = true;
+ controlRenderer = factory.CreateControlRenderer( map );
controlRenderer.SetOnStage( actor );
application.SendNotification();
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
// A lookup texture is generated and pass to shader as sampler
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
// A lookup texture is generated and pass to shader as sampler
stopColors.PushBack( Color::GREEN );
propertyMap.Insert("stopColor", stopColors);
- ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
+ ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
DALI_TEST_CHECK( controlRenderer );
// A lookup texture is generated and pass to shader as sampler
propertyMap.Insert( "rendererType", "image" );
propertyMap.Insert( "url", TEST_IMAGE_FILE_NAME );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
DALI_TEST_CHECK( factory );
Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- ControlRenderer controlRenderer = factory.GetControlRenderer( image );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( image );
Actor actor = Actor::New();
// For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
{
tet_infoline( "whole grid" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert( "rendererType", "image" );
propertyMap.Insert( "url", TEST_NPATCH_FILE_NAME );
{
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert( "borderOnly", true );
{
tet_infoline( "border only" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
TestGlAbstraction& gl = application.GetGlAbstraction();
stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
- ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
- ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
RendererFactory factory = RendererFactory::Get();
DALI_TEST_CHECK( factory );
- ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( "ERROR.9.jpg", ImageDimensions() );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert( "rendererType", 111 );
propertyMap.Insert( "url", "ERROR.9.jpg" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
tet_infoline( "UtcDaliRendererFactoryGetSvgRenderer: Request svg renderer with a svg url" );
RendererFactory factory = RendererFactory::Get();
- ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_SVG_FILE_NAME );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_SVG_FILE_NAME, ImageDimensions() );
DALI_TEST_CHECK( controlRenderer );
TestGlAbstraction& gl = application.GetGlAbstraction();
propertyMap.Insert( "rendererType", "mesh" );
propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
Actor actor = Actor::New();
propertyMap.Insert( "materialUrl", "" );
propertyMap.Insert( "texturesPath", "" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
propertyMap.Insert( "materialUrl", TEST_SIMPLE_MTL_FILE_NAME );
propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
propertyMap.Insert( "materialUrl", "invalid" );
propertyMap.Insert( "texturesPath", "also invalid" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
- ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
+ ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
DALI_TEST_CHECK( controlRenderer );
//Add renderer to an actor on stage.
END_TEST;
}
-
-int UtcDaliRendererFactoryResetRenderer1(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
-
- RendererFactory factory = RendererFactory::Get();
- DALI_TEST_CHECK( factory );
-
- ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
- DALI_TEST_CHECK( controlRenderer );
-
- Actor actor = Actor::New();
- TestControlRendererRender( application, actor, controlRenderer );
-
- Vector4 actualValue(Vector4::ZERO);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
-
- factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
- application.SendNotification();
- application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
-
- Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
- factory.ResetRenderer( controlRenderer, actor, bufferImage );
-
- Actor actor2 = Actor::New();
- actor2.SetSize(200.f, 200.f);
- Stage::GetCurrent().Add( actor2 );
- controlRenderer.SetSize(Vector2(200.f, 200.f));
- controlRenderer.SetOnStage( actor2 );
- application.SendNotification();
- application.Render(0);
-
- END_TEST;
-}
-
-int UtcDaliRendererFactoryResetRenderer2(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
-
- Actor actor = Actor::New();
- actor.SetSize(200.f, 200.f);
- Stage::GetCurrent().Add( actor );
- RendererFactory factory = RendererFactory::Get();
- DALI_TEST_CHECK( factory );
-
- Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
- DALI_TEST_CHECK( controlRenderer );
- controlRenderer.SetSize(Vector2(200.f, 200.f));
- controlRenderer.SetOnStage( actor );
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- application.SendNotification();
- application.Render(0);
-
- Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
- factory.ResetRenderer( controlRenderer, actor, bufferImage );
- application.SendNotification();
- application.Render(0);
-
- factory.ResetRenderer( controlRenderer, actor, Color::RED );
-
- Actor actor2 = Actor::New();
- actor2.SetSize(200.f, 200.f);
- Stage::GetCurrent().Add( actor2 );
- controlRenderer.SetSize(Vector2(200.f, 200.f));
- controlRenderer.SetOnStage( actor2 );
- TestGlAbstraction& gl = application.GetGlAbstraction();
- application.SendNotification();
- application.Render(0);
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliRendererFactoryResetRenderer3(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliRendererFactoryResetRenderer3" );
-
- Actor actor = Actor::New();
- actor.SetSize(200.f, 200.f);
- Stage::GetCurrent().Add( actor );
- RendererFactory factory = RendererFactory::Get();
- DALI_TEST_CHECK( factory );
-
- // Get renderer for rendering a resource image
- Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
- ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
- DALI_TEST_CHECK( controlRenderer );
- controlRenderer.SetSize(Vector2(200.f, 200.f));
- controlRenderer.SetOnStage( actor );
- application.SendNotification();
- application.Render();
-
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- // reset the renderer to renderer a svg image
- factory.ResetRenderer( controlRenderer, actor, TEST_SVG_FILE_NAME, ImageDimensions( 100, 100 ) );
- application.SendNotification();
- application.Render();
-
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- EventThreadCallback* eventTrigger = EventThreadCallback::Get();
- CallbackBase* callback = eventTrigger->GetCallback();
-
- eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
- CallbackBase::Execute( *callback );
-
- END_TEST;
-}
-
-//Test resetting mesh and primitive shape renderers
-int UtcDaliRendererFactoryResetRenderer4(void)
-{
- ToolkitTestApplication application;
- tet_infoline( "UtcDaliRendererFactoryResetRenderer4: Mesh and primitive renderers" );
-
- Actor actor = Actor::New();
- actor.SetSize( 200.f, 200.f );
- Stage::GetCurrent().Add( actor );
- RendererFactory factory = RendererFactory::Get();
- DALI_TEST_CHECK( factory );
-
- Property::Map map;
-
- //******
-
- //Start with basic color renderer
- ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
- DALI_TEST_CHECK( controlRenderer );
-
- TestControlRendererRender( application, actor, controlRenderer );
-
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- //Ensure set correctly.
- Vector4 actualValue( Vector4::ZERO );
- TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
-
- //******
-
- //Reset to mesh renderer
- map.Insert( "rendererType", "mesh" );
- map.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
- map.Insert( "materialUrl", TEST_MTL_FILE_NAME );
- map.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
- factory.ResetRenderer( controlRenderer, actor, map );
- application.SendNotification();
- application.Render( 0 );
-
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- //Tell the platform abstraction that the required resources have been loaded.
- TestPlatformAbstraction& platform = application.GetPlatform();
- platform.SetAllResourceRequestsAsLoaded();
-
- //Render again to upload the now-loaded textures.
- application.SendNotification();
- application.Render( 0 );
-
- //Ensure set correctly.
- controlRenderer.CreatePropertyMap( map );
- DALI_TEST_EQUALS( map.Find( "objectUrl", Property::STRING )->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
-
- Matrix testScaleMatrix;
- testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
- Matrix actualScaleMatrix;
-
- //Test to see if the object has been successfully loaded.
- DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
- DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
-
- //******
-
- //Reset back to color renderer
- factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
- application.SendNotification();
- application.Render( 0 );
-
- DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
-
- //Ensure set correctly.
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
-
- //******
-
- END_TEST;
-}
Actor solidColorActor = Actor::New();
RendererFactory factory = RendererFactory::Get();
- ControlRenderer colorRenderer = factory.GetControlRenderer( color );
+ Dali::Property::Map map;
+ map[ "rendererType" ] = "color";
+ map[ "mixColor" ] = color;
+ ControlRenderer colorRenderer = factory.CreateControlRenderer( map );
colorRenderer.SetOnStage( solidColorActor );
return solidColorActor;
{
}
-ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
+ControlRenderer RendererFactory::CreateControlRenderer( const Property::Map& propertyMap )
{
- return GetImplementation( *this ).GetControlRenderer( propertyMap );
+ return GetImplementation( *this ).CreateControlRenderer( propertyMap );
}
-ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
+ControlRenderer RendererFactory::CreateControlRenderer( const Image& image )
{
- return GetImplementation( *this ).GetControlRenderer( color );
+ return GetImplementation( *this ).CreateControlRenderer( image );
}
-void RendererFactory::ResetRenderer( ControlRenderer& renderer, Actor& actor, const Vector4& color )
+ControlRenderer RendererFactory::CreateControlRenderer( const std::string& url, ImageDimensions size )
{
- GetImplementation( *this ).ResetRenderer( renderer, actor, color );
-}
-
-ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor )
-{
- return GetImplementation( *this ).GetControlRenderer( borderSize, borderColor, false );
-}
-
-
-ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor, bool antiAliasing )
-{
- return GetImplementation( *this ).GetControlRenderer( borderSize, borderColor, antiAliasing );
-}
-
-ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
-{
- return GetImplementation( *this ).GetControlRenderer( image );
-}
-
-void RendererFactory::ResetRenderer( ControlRenderer& renderer, Actor& actor, const Image& image )
-{
- GetImplementation( *this ).ResetRenderer( renderer, actor, image );
-}
-
-ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
-{
- return GetImplementation( *this ).GetControlRenderer( url, size );
-}
-
-void RendererFactory::ResetRenderer( ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
-{
- GetImplementation( *this ).ResetRenderer( renderer, actor, url, size );
-}
-
-void RendererFactory::ResetRenderer( ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
-{
- GetImplementation( *this ).ResetRenderer( renderer, actor, propertyMap );
+ return GetImplementation( *this ).CreateControlRenderer( url, size );
}
} // namespace Toolkit
// EXTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/images/image-operations.h>
+#include <dali/public-api/object/property-map.h>
// INTERNAK INCLUDES
#include <dali-toolkit/devel-api/controls/renderer-factory/control-renderer.h>
* Depends on the content of the map, different kind of renderer would be returned.
* @return The pointer pointing to control renderer
*/
- ControlRenderer GetControlRenderer( const Property::Map& propertyMap );
-
- /**
- * @brief Request the control renderer to render the given color
- *
- * @param[in] color The color to be rendered
- * @return The pointer pointing to the control renderer
- */
- ControlRenderer GetControlRenderer( const Vector4& color );
-
- /**
- * @brief Request the current control renderer to render the given color
- *
- * if the current renderer is a handle to an internal color renderer, set this color to it,
- * else the renderer would be a handle to a newly created internal color renderer.
- *
- * @param[in] renderer The ControlRenderer to reset
- * @param[in] actor The Actor the renderer is applied to, empty if the renderer has not been applied to any Actor
- * @param[in] color The color to be rendered.
- */
- void ResetRenderer( ControlRenderer& renderer, Actor& actor, const Vector4& color );
-
- /**
- * @brief Request the control renderer to renderer the border with the given size and color.
- *
- * @param[in] borderSize The size of the border. Border size is the same along all edges.
- * @param[in] borderColor The color of the border.
- * @return The pointer pointing to the control renderer
- */
- ControlRenderer GetControlRenderer( float borderSize, const Vector4& borderColor );
-
- /**
- * @brief Request the control renderer to renderer the border with the given size and color, and specify whether anti-aliasing is needed.
- *
- * @param[in] borderSize The size of the border. Border size is the same along all edges.
- * @param[in] borderColor The color of the border.
- * @param[in] antiAliasing Whether anti-aliasing is required for border rendering.
- * @return The pointer pointing to the control renderer
- */
- ControlRenderer GetControlRenderer( float borderSize, const Vector4& borderColor, bool antiAliasing );
+ ControlRenderer CreateControlRenderer( const Property::Map& propertyMap );
/**
* @brief Request the control renderer to render the image.
* @param[in] image The image to be rendered.
* @return The pointer pointing to the control renderer
*/
- ControlRenderer GetControlRenderer( const Image& image );
-
- /**
- * @brief Request the current control renderer to render the given image
- *
- * if the current renderer is a handle to an internal image renderer, set this image to it,
- * else the renderer would be a handle to a newly created internal image renderer.
- *
- * @param[in] renderer The ControlRenderer to reset
- * @param[in] actor The Actor the renderer is applied to, empty if the renderer has not been applied to any Actor
- * @param[in] image The Image to be rendered.
- */
- void ResetRenderer( ControlRenderer& renderer, Actor& actor, const Image& image );
+ ControlRenderer CreateControlRenderer( const Image& image );
/**
* @brief Request the control renderer to render the given resource at the url.
* @param[in] size The width and height to fit the loaded image to.
* @return The pointer pointing to the control renderer
*/
- ControlRenderer GetControlRenderer( const std::string& url,
- ImageDimensions size = ImageDimensions() );
-
- /**
- * @brief Request the current control renderer to render the given resource at the url
- *
- * if the current renderer is a handle to an internal image renderer, set this image to it,
- * else the renderer would be a handle to a newly created internal image renderer.
- *
- * @param[in] renderer The ControlRenderer to reset
- * @param[in] actor The Actor the renderer is applied to, empty if the renderer has not been applied to any Actor
- * @param[in] url The URL to the resource to be rendered.
- * @param[in] size The width and height to fit the loaded image to.
- */
- void ResetRenderer( ControlRenderer& renderer, Actor& actor, const std::string& url,
- ImageDimensions size = ImageDimensions() );
-
- /**
- * @brief Request the current control renderer from the property map, merging the property map with the renderer
- *
- * if the current renderer is capable of merging with the property map the reset the renderer with the merged properties
- * else the renderer would be a handle to a newly created internal renderer.
- *
- * @param[in] renderer The ControlRenderer to reset
- * @param[in] actor The Actor the renderer is applied to, empty if the renderer has not been applied to any Actor
- * @param[in] propertyMap The map contains the properties required by the control renderer
- * Depends on the content of the map, different kind of renderer would be returned.
- */
- void ResetRenderer( ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap );
+ ControlRenderer CreateControlRenderer( const std::string& url, ImageDimensions size );
private:
};
+
+/**
+ * @brief Template to allow discard old renderer, get new one and set it on stage if possible
+ *
+ * @tparam ParameterType0 The type of first argument passed to the CreateControlRenderer()
+ * @tparam ParameterType1 The type of second argument passed to the CreateControlRenderer()
+ * @SINCE_1_0.39
+ * @param[in] actor Actor for which the renderer will be replaced
+ * @param[in,out] renderer The renderer object to be replaced
+ * @param[in] param0 First template based argument passed to the renderer factory
+ * @param[in] param1 Second template based argument passed to the renderer factory
+ */
+template< class ParameterType0, class ParameterType1 >
+void InitializeControlRenderer( Actor& actor, ControlRenderer& renderer, ParameterType0& param0, ParameterType1& param1 )
+{
+ renderer.RemoveAndReset( actor );
+ renderer = Toolkit::RendererFactory::Get().CreateControlRenderer( param0, param1 );
+ if( renderer && actor && actor.OnStage() )
+ {
+ renderer.SetOnStage( actor );
+ }
+}
+
+/**
+ * @brief Template to allow discard old renderer, get new one and set it on stage if possible
+ *
+ * @tparam ParameterType The type of argument passed to the CreateControlRenderer()
+ * @SINCE_1_0.39
+ * @param[in] actor Actor for which the renderer will be replaced
+ * @param[in,out] renderer The renderer object to be replaced
+ * @param[in] param Template based argument passed to the renderer factory
+ */
+template< class ParameterType >
+void InitializeControlRenderer( Actor& actor, ControlRenderer& renderer, ParameterType& param )
+{
+ renderer.RemoveAndReset( actor );
+ renderer = Toolkit::RendererFactory::Get().CreateControlRenderer( param );
+ if( renderer && actor && actor.OnStage() )
+ {
+ renderer.SetOnStage( actor );
+ }
+}
+
} // namespace Toolkit
} // namespace Dali
+
#endif /* __DALI_TOOLKIT_RENDERER_FACTORY_H__ */
mBloomExtractImageView = Toolkit::ImageView::New();
mBloomExtractImageView.SetParentOrigin( ParentOrigin::CENTER );
- // Create shader used for extracting the bright parts of an image
- Property::Map customShader;
- customShader[ "fragmentShader" ] = BLOOM_EXTRACT_FRAGMENT_SOURCE;
- Property::Map rendererMap;
- rendererMap.Insert( "rendererType", "image" );
- rendererMap.Insert( "shader", customShader );
- mBloomExtractImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
-
// Create an image view for compositing the result (scene and bloom textures) to output
mCompositeImageView = Toolkit::ImageView::New();
mCompositeImageView.SetParentOrigin( ParentOrigin::CENTER );
- // Create shader used to composite bloom and original image to output render target
- customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE;
- rendererMap[ "shader" ] = customShader;
- mCompositeImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
-
// Create an image view for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task
mTargetImageView = Toolkit::ImageView::New();
mTargetImageView.SetParentOrigin( ParentOrigin::CENTER );
mBloomExtractImageView.SetImage( mRenderTargetForRenderingChildren );
mBloomExtractImageView.SetSize(mDownsampledWidth, mDownsampledHeight); // size needs to match render target
+ // Create shader used for extracting the bright parts of an image
+ Property::Map customShader;
+ customShader[ "fragmentShader" ] = BLOOM_EXTRACT_FRAGMENT_SOURCE;
+ Property::Map rendererMap;
+ rendererMap.Insert( "shader", customShader );
+ mBloomExtractImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
// set GaussianBlurView to blur our extracted bloom
mGaussianBlurView.SetUserImageAndOutputRenderTarget(mBloomExtractTarget, mBlurExtractTarget);
// use the completed blur in the first buffer and composite with the original child actors render
mCompositeImageView.SetImage( mRenderTargetForRenderingChildren );
+ // Create shader used to composite bloom and original image to output render target
+ customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE;
+ rendererMap[ "shader" ] = customShader;
+ mCompositeImageView.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
TextureSet textureSet = mCompositeImageView.GetRendererAt(0).GetTextures();
textureSet.SetImage( 1u, mBlurExtractTarget );
mBackgroundImage = bgImage;
mHSVDelta = hsvDelta;
- Toolkit::ImageView sourceActor = Toolkit::ImageView::New( bgImage );
+ Toolkit::ImageView sourceActor = Toolkit::ImageView::New(bgImage);
sourceActor.SetSize( mMovementArea );
sourceActor.SetParentOrigin(ParentOrigin::CENTER);
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/devel-api/rendering/renderer.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
+#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
#include <dali-toolkit/internal/filters/blur-two-pass-filter.h>
#include <dali-toolkit/internal/filters/emboss-filter.h>
#include <dali-toolkit/internal/filters/spread-filter.h>
customShader[ "vertexShader" ] = EFFECTS_VIEW_VERTEX_SOURCE;
customShader[ "fragmentShader" ] = EFFECTS_VIEW_FRAGMENT_SOURCE;
rendererMap[ "shader" ] = customShader;
- Toolkit::RendererFactory::Get().ResetRenderer( mRendererPostFilter, self, rendererMap );
+ InitializeControlRenderer( self, mRendererPostFilter, rendererMap );
mEffectType = type;
}
mLastSize = mTargetSize;
SetupCameras();
- Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
- Actor self = Self();
+ Actor self( Self() );
mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
- rendererFactory.ResetRenderer(mRendererForChildren, self, mImageForChildren);
+ InitializeControlRenderer( self, mRendererForChildren, mImageForChildren );
mRendererForChildren.SetDepthIndex( DepthIndex::CONTENT+1 );
mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
- rendererFactory.ResetRenderer(mRendererPostFilter, self, mImagePostFilter);
+ TextureSet textureSet = TextureSet::New();
+ textureSet.SetImage( 0u, mImagePostFilter);
+ self.GetRendererAt( 0 ).SetTextures( textureSet );
mRendererPostFilter.SetDepthIndex( DepthIndex::CONTENT );
SetupFilters();
#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/animation/constraints.h>
#include <dali/public-api/common/stage.h>
-#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
#include <dali/public-api/render-tasks/render-task-list.h>
mUserInputImage = inputImage;
mImageViewHorizBlur.SetImage( mUserInputImage );
+ mImageViewHorizBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader );
mUserOutputRenderTarget = outputRenderTarget;
}
std::ostringstream horizFragmentShaderStringStream;
horizFragmentShaderStringStream << "#define NUM_SAMPLES " << mNumSamples << "\n";
horizFragmentShaderStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE;
- Property::Map customShader;
- customShader[ "fragmentShader" ] = horizFragmentShaderStringStream.str();
- Property::Map rendererMap;
- rendererMap.Insert( "rendererType", "image" );
- rendererMap.Insert( "shader", customShader );
+ Property::Map source;
+ source[ "fragmentShader" ] = horizFragmentShaderStringStream.str();
+ mCustomShader["shader"] = source;
//////////////////////////////////////////////////////
// Create actors
// Create an image view for performing a horizontal blur on the texture
mImageViewHorizBlur = Toolkit::ImageView::New();
mImageViewHorizBlur.SetParentOrigin(ParentOrigin::CENTER);
- mImageViewHorizBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
// Create an image view for performing a vertical blur on the texture
mImageViewVertBlur = Toolkit::ImageView::New();
mImageViewVertBlur.SetParentOrigin(ParentOrigin::CENTER);
- mImageViewVertBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
// Register a property that the user can control to fade the blur in / out via the GaussianBlurView object
Actor self = Self();
// Set image view for performing a horizontal blur on the texture
mImageViewHorizBlur.SetImage( mRenderTargetForRenderingChildren );
+ mImageViewHorizBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader );
// Create offscreen buffer for vert blur pass
mRenderTarget1 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat );
// size needs to match render target
mImageViewVertBlur.SetImage( mRenderTarget2 );
+ mImageViewVertBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader );
mImageViewVertBlur.SetSize(mDownsampledWidth, mDownsampledHeight);
// set gaussian blur up for new sized render targets
// EXTERNAL INCLUDES
#include <sstream>
#include <cmath>
+#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control-impl.h>
Toolkit::ImageView mImageViewHorizBlur;
Toolkit::ImageView mImageViewVertBlur;
+ Property::Map mCustomShader;
+
RenderTask mHorizBlurTask;
RenderTask mVertBlurTask;
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/image-view/image-view.h>
#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
+#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
+#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
namespace Dali
{
mImage = image;
- Actor self = Self();
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, image );
+ Actor self( Self() );
+ InitializeControlRenderer( self, mRenderer, image );
mImageSize = image ? ImageDimensions( image.GetWidth(), image.GetHeight() ) : ImageDimensions( 0, 0 );
RelayoutRequest();
mImage.Reset();
mPropertyMap = map;
- Actor self = Self();
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mPropertyMap );
+ Actor self( Self() );
+ InitializeControlRenderer( self, mRenderer, mPropertyMap );
Property::Value* widthValue = mPropertyMap.Find( "width" );
if( widthValue )
void ImageView::SetImage( const std::string& url, ImageDimensions size )
{
if( ( mUrl != url ) ||
- mImage || // If we're changing from an Image type to a URL type
+ mImage || // If we're changing from an Image type to a URL type
! mPropertyMap.Empty() ) // If we're changing from a property map type to a URL type
{
mImage.Reset();
mImageSize = size;
}
- Actor self = Self();
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mUrl, size );
+ Actor self( Self() );
+ InitializeControlRenderer( self, mRenderer, url, size );
+
+ mRenderer.SetSize( mSizeSet );
RelayoutRequest();
}
void ImageView::OnSizeSet( const Vector3& targetSize )
{
Control::OnSizeSet( targetSize );
+ mSizeSet = targetSize;
if( mRenderer )
{
if ( imageView )
{
+ ImageView& impl = GetImpl( imageView );
switch ( index )
{
case Toolkit::ImageView::Property::RESOURCE_URL:
std::string imageUrl;
if( value.Get( imageUrl ) )
{
- GetImpl( imageView ).SetImage( imageUrl, ImageDimensions() );
+ impl.SetImage( imageUrl, ImageDimensions() );
}
break;
}
case Toolkit::ImageView::Property::IMAGE:
{
std::string imageUrl;
+ Property::Map map;
if( value.Get( imageUrl ) )
{
- ImageView& impl = GetImpl( imageView );
impl.SetImage( imageUrl, ImageDimensions() );
}
-
// if its not a string then get a Property::Map from the property if possible.
- Property::Map map;
- if( value.Get( map ) )
+ else if( value.Get( map ) )
{
- ImageView& impl = GetImpl( imageView );
- impl.SetImage( map );
+ Property::Value* shaderValue = map.Find( "shader" );
+ // set image only if property map contains image information other than custom shader
+ if( map.Count() > 1u || !shaderValue )
+ {
+ impl.SetImage( map );
+ }
+ // the property map contains only the custom shader
+ else if( impl.mRenderer && map.Count() == 1u && shaderValue )
+ {
+ Property::Map shaderMap;
+ if( shaderValue->Get( shaderMap ) )
+ {
+ Internal::ControlRenderer& renderer = GetImplementation( impl.mRenderer );
+ renderer.SetCustomShader( shaderMap );
+ if( imageView.OnStage() )
+ {
+ // force to create new core renderer to use the newly set shader
+ renderer.SetOffStage( imageView );
+ renderer.SetOnStage( imageView );
+ }
+ }
+ }
}
-
break;
}
bool isPre;
if( value.Get( isPre ) )
{
- GetImpl(imageView).EnablePreMultipliedAlpha( isPre );
+ impl.EnablePreMultipliedAlpha( isPre );
}
break;
}
private:
Toolkit::ControlRenderer mRenderer;
ImageDimensions mImageSize;
+ Vector2 mSizeSet;
std::string mUrl; ///< the url for the image if the image came from a URL, empty otherwise
Image mImage; ///< the Image if the image came from a Image, null otherwise
#include <dali/public-api/images/resource-image.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/object/property-map.h>
// INTERNAL INCLUDES
#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
+#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
namespace Dali
{
Vector3 sizeOffset(IMAGE_BORDER_INDENT*2.f - 2.f, IMAGE_BORDER_INDENT*2.f - 2.f, 0.0f);
mFrame.SetSizeModeFactor( sizeOffset );
- //TODO Set the renderer onto the control self when Actor::RemoveRenderer is supported
Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
- Toolkit::ControlRenderer borderRenderer = rendererFactory.GetControlRenderer(IMAGE_BORDER_INDENT, Color::WHITE);
+
+ Property::Map map;
+ map[ RENDERER_TYPE ] = BORDER_RENDERER;
+ map[ "borderColor" ] = Color::WHITE;
+ map[ "borderSize" ] = IMAGE_BORDER_INDENT;
+ Toolkit::ControlRenderer borderRenderer = rendererFactory.CreateControlRenderer( map );
borderRenderer.SetOnStage( mFrame );
Constraint constraint = Constraint::New<Vector3>( mFrame, Actor::Property::POSITION, EqualToConstraint() );
SetPropertyMap( map );
}
-void Internal::ControlRenderer::Impl::CustomShader::SetPropertyMap( const Property::Map& propertyMap )
+void Internal::ControlRenderer::Impl::CustomShader::SetPropertyMap( const Property::Map& shaderMap )
{
- Property::Value* shaderValue = propertyMap.Find( CUSTOM_SHADER );
- if( shaderValue )
+ mVertexShader.clear();
+ mFragmentShader.clear();
+ mGridSize = ImageDimensions( 1, 1 );
+ mHints = Shader::HINT_NONE;
+
+ Property::Value* vertexShaderValue = shaderMap.Find( CUSTOM_VERTEX_SHADER );
+ if( vertexShaderValue )
{
- mVertexShader.clear();
- mFragmentShader.clear();
- mGridSize = ImageDimensions( 1, 1 );
- mHints = Shader::HINT_NONE;
+ if( !vertexShaderValue->Get( mVertexShader ) )
+ {
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_VERTEX_SHADER );
+ }
+ }
- Property::Map shaderMap;
- if( shaderValue->Get( shaderMap ) )
+ Property::Value* fragmentShaderValue = shaderMap.Find( CUSTOM_FRAGMENT_SHADER );
+ if( fragmentShaderValue )
+ {
+ if( !fragmentShaderValue->Get( mFragmentShader ) )
{
- Property::Value* vertexShaderValue = shaderMap.Find( CUSTOM_VERTEX_SHADER );
- if( vertexShaderValue )
- {
- if( !vertexShaderValue->Get( mVertexShader ) )
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_VERTEX_SHADER );
- }
- }
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_FRAGMENT_SHADER );
+ }
+ }
- Property::Value* fragmentShaderValue = shaderMap.Find( CUSTOM_FRAGMENT_SHADER );
- if( fragmentShaderValue )
- {
- if( !fragmentShaderValue->Get( mFragmentShader ) )
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_FRAGMENT_SHADER );
- }
- }
+ Property::Value* subdivideXValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_X );
+ if( subdivideXValue )
+ {
+ int subdivideX;
+ if( !subdivideXValue->Get( subdivideX ) || subdivideX < 1 )
+ {
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_X );
+ }
+ else
+ {
+ mGridSize = ImageDimensions( subdivideX, mGridSize.GetY() );
+ }
+ }
- Property::Value* subdivideXValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_X );
- if( subdivideXValue )
- {
- int subdivideX;
- if( !subdivideXValue->Get( subdivideX ) || subdivideX < 1 )
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_X );
- }
- else
- {
- mGridSize = ImageDimensions( subdivideX, mGridSize.GetY() );
- }
- }
+ Property::Value* subdivideYValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_Y );
+ if( subdivideYValue )
+ {
+ int subdivideY;
+ if( !subdivideYValue->Get( subdivideY ) || subdivideY < 1 )
+ {
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_Y );
+ }
+ else
+ {
+ mGridSize = ImageDimensions( mGridSize.GetX(), subdivideY );
+ }
+ }
- Property::Value* subdivideYValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_Y );
- if( subdivideYValue )
- {
- int subdivideY;
- if( !subdivideYValue->Get( subdivideY ) || subdivideY < 1 )
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_Y );
- }
- else
- {
- mGridSize = ImageDimensions( mGridSize.GetX(), subdivideY );
- }
- }
+ Property::Value* hintsValue = shaderMap.Find( CUSTOM_SHADER_HINTS );
+ if( hintsValue )
+ {
+ std::string hintString;
+ Property::Array hintsArray;
- Property::Value* hintsValue = shaderMap.Find( CUSTOM_SHADER_HINTS );
- if( hintsValue )
+ if( hintsValue->Get( hintString ) )
+ {
+ mHints = HintFromString( hintString );
+ }
+ else if( hintsValue->Get( hintsArray ) )
+ {
+ int hints = Shader::HINT_NONE;
+ for( Property::Array::SizeType i = 0; i < hintsArray.Count(); ++i)
{
- std::string hintString;
- Property::Array hintsArray;
-
- if( hintsValue->Get( hintString ) )
- {
- mHints = HintFromString( hintString );
- }
- else if( hintsValue->Get( hintsArray ) )
+ Property::Value hintValue = hintsArray[ i ];
+ if( hintValue.Get( hintString ) )
{
- int hints = Shader::HINT_NONE;
- for( Property::Array::SizeType i = 0; i < hintsArray.Count(); ++i)
- {
- Property::Value hintValue = hintsArray[ i ];
- if( hintValue.Get( hintString ) )
- {
- hints |= static_cast< int >( HintFromString( hintString ) );
- }
- else
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify an hint string at index %d", CUSTOM_SHADER_HINTS, i );
- }
-
- mHints = static_cast< Shader::ShaderHints >( hints );
- }
+ hints |= static_cast< int >( HintFromString( hintString ) );
}
else
{
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a hint string or an array of hint strings", CUSTOM_SHADER_HINTS );
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify an hint string at index %d", CUSTOM_SHADER_HINTS, i );
}
+
+ mHints = static_cast< Shader::ShaderHints >( hints );
}
}
else
{
- //use value with no type to mean reseting the shader back to default
- if( shaderValue->GetType() != Dali::Property::NONE )
- {
- DALI_LOG_ERROR( "'%s' parameter does not correctly specify a property map", CUSTOM_SHADER );
- }
+ DALI_LOG_ERROR( "'%s' parameter does not correctly specify a hint string or an array of hint strings", CUSTOM_SHADER_HINTS );
}
}
}
delete mImpl;
}
-void ControlRenderer::Initialize( Actor& actor, const Property::Map& propertyMap )
+void ControlRenderer::SetCustomShader( const Property::Map& shaderMap )
{
if( mImpl->mCustomShader )
{
- mImpl->mCustomShader->SetPropertyMap( propertyMap );
+ mImpl->mCustomShader->SetPropertyMap( shaderMap );
}
else
{
- Property::Value* customShaderValue = propertyMap.Find( CUSTOM_SHADER );
- if( customShaderValue )
+ mImpl->mCustomShader = new Impl::CustomShader( shaderMap );
+ }
+}
+
+void ControlRenderer::Initialize( Actor& actor, const Property::Map& propertyMap )
+{
+ Property::Value* customShaderValue = propertyMap.Find( CUSTOM_SHADER );
+ if( customShaderValue )
+ {
+ Property::Map shaderMap;
+ if( customShaderValue->Get( shaderMap ) )
{
- Property::Map customShader;
- if( customShaderValue->Get( customShader ) )
- {
- mImpl->mCustomShader = new Impl::CustomShader( propertyMap );
- }
+ SetCustomShader( shaderMap );
}
}
+
DoInitialize( actor, propertyMap );
}
*/
bool IsPreMultipliedAlphaEnabled() const;
+ /**
+ * @brief Sets properties of custom shader
+ * @param[in] propertyMap Property map containing the custom shader data
+ */
+ void SetCustomShader( const Property::Map& propertyMap );
+
protected:
/**
return rendererType;
}
-Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Property::Map& propertyMap )
+Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const Property::Map& propertyMap )
{
ControlRenderer* rendererPtr = NULL;
return Toolkit::ControlRenderer( rendererPtr );
}
-Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Vector4& color )
-{
- if( !mFactoryCache )
- {
- mFactoryCache = new RendererFactoryCache();
- }
-
- if( mDebugEnabled )
- {
- return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
- }
-
- ColorRenderer* rendererPtr = new ColorRenderer( *( mFactoryCache.Get() ) );
- rendererPtr->SetColor( color );
-
- return Toolkit::ControlRenderer( rendererPtr );
-}
-
-void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color )
-{
- if( mDebugEnabled && renderer )
- {
- return;
- }
-
- if( renderer )
- {
- ColorRenderer* rendererPtr = dynamic_cast< ColorRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetColor( color );
- return;
- }
-
- renderer.RemoveAndReset( actor );
- }
-
- renderer = GetControlRenderer( color );
- if( actor && actor.OnStage() )
- {
- renderer.SetOnStage( actor );
- }
-}
-
-Toolkit::ControlRenderer RendererFactory::GetControlRenderer( float borderSize, const Vector4& borderColor, bool antiAliasing )
-{
- if( !mFactoryCache )
- {
- mFactoryCache = new RendererFactoryCache();
- }
-
- if( mDebugEnabled )
- {
- return Toolkit::ControlRenderer( new DebugRenderer( *( mFactoryCache.Get() ) ) );
- }
-
- BorderRenderer* rendererPtr = new BorderRenderer( *mFactoryCache.Get() );
-
- rendererPtr->SetBorderSize( borderSize );
- rendererPtr->SetBorderColor( borderColor );
- rendererPtr->RequireAntiAliasing( antiAliasing );
-
- return Toolkit::ControlRenderer( rendererPtr );
-}
-
-Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const Image& image )
+Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const Image& image )
{
if( !mFactoryCache )
{
}
}
-void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image )
-{
- if( mDebugEnabled && renderer )
- {
- return;
- }
-
- if( renderer )
- {
- if( ! image )
- {
- // If the image is empty, then reset the renderer and return
- renderer.RemoveAndReset( actor );
- return;
- }
-
- NinePatchImage npatchImage = NinePatchImage::DownCast( image );
- if( npatchImage )
- {
- NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetImage( npatchImage );
- return;
- }
- }
- else
- {
- ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetImage( actor, image );
- return;
- }
- }
-
- renderer.RemoveAndReset( actor );
- }
-
- renderer = GetControlRenderer( image );
- if( actor && actor.OnStage() )
- {
- renderer.SetOnStage( actor );
- }
-}
-
-Toolkit::ControlRenderer RendererFactory::GetControlRenderer( const std::string& url, ImageDimensions size )
+Toolkit::ControlRenderer RendererFactory::CreateControlRenderer( const std::string& url, ImageDimensions size )
{
if( !mFactoryCache )
{
}
}
-void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& url, ImageDimensions size )
-{
- if( mDebugEnabled && renderer )
- {
- return;
- }
-
- if( renderer )
- {
- if( url.empty() )
- {
- // If the URL is empty, then reset the renderer and return
- renderer.RemoveAndReset( actor );
- return;
- }
- else if( NinePatchImage::IsNinePatchUrl( url ) )
- {
- NPatchRenderer* rendererPtr = dynamic_cast< NPatchRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetImage( url );
- return;
- }
- }
- else if( SvgRenderer::IsSvgUrl( url ) )
- {
- SvgRenderer* rendererPtr = dynamic_cast< SvgRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetImage( url, size );
- return;
- }
- }
- else
- {
- ImageRenderer* rendererPtr = dynamic_cast< ImageRenderer* >( &GetImplementation( renderer ) );
- if( rendererPtr )
- {
- rendererPtr->SetImage( actor, url, size );
- return;
- }
- }
-
- renderer.RemoveAndReset( actor );
- }
-
- renderer = GetControlRenderer( url, size );
- if( actor && actor.OnStage() )
- {
- renderer.SetOnStage( actor );
- }
-}
-
-void RendererFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
-{
- if( mDebugEnabled && renderer )
- {
- return;
- }
-
- if( renderer )
- {
- ControlRenderer& controlRenderer = GetImplementation( renderer );
-
- RendererType type = GetRendererType( propertyMap );
-
- //If there's no renderer type specified or if there hasn't been a renderer type change then we can reuse the renderer
- if( type == UNDEFINED ||
- ( type == IMAGE && typeid( controlRenderer ) == typeid( ImageRenderer ) ) ||
- ( type == N_PATCH && typeid( controlRenderer ) == typeid( NPatchRenderer ) ) ||
- ( type == COLOR && typeid( controlRenderer ) == typeid( ColorRenderer ) ) ||
- ( type == GRADIENT && typeid( controlRenderer ) == typeid( GradientRenderer ) ) ||
- ( type == BORDER && typeid( controlRenderer ) == typeid( BorderRenderer ) ) ||
- ( type == SVG && typeid( controlRenderer ) == typeid( SvgRenderer ) ) ||
- ( type == MESH && typeid( controlRenderer ) == typeid( MeshRenderer ) ) )
- {
- controlRenderer.Initialize( actor, propertyMap );
- return;
- }
-
- renderer.RemoveAndReset( actor );
- }
-
- renderer = GetControlRenderer( propertyMap );
- if( renderer && actor && actor.OnStage() )
- {
- renderer.SetOnStage( actor );
- }
-}
-
Image RendererFactory::GetBrokenRendererImage()
{
return ResourceImage::New( BROKEN_RENDERER_IMAGE_URL );
RendererFactory( bool debugEnabled );
/**
- * @copydoc Toolkit::RenderFactory::GetControlRenderer( const Property::Map& )
+ * @copydoc Toolkit::RenderFactory::CreateControlRenderer( const Property::Map& )
*/
- Toolkit::ControlRenderer GetControlRenderer( const Property::Map& propertyMap );
+ Toolkit::ControlRenderer CreateControlRenderer( const Property::Map& propertyMap );
/**
- * @copydoc Toolkit::RenderFactory::ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap )
+ * @copydoc Toolkit::RenderFactory::CreateControlRenderer( const Image& )
*/
- void ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Property::Map& propertyMap );
+ Toolkit::ControlRenderer CreateControlRenderer( const Image& image );
/**
- * @copydoc Toolkit::RenderFactory::GetControlRenderer( const Vector4& )
+ * @copydoc Toolkit::RenderFactory::CreateControlRenderer( const std::string&, ImageDimensions )
*/
- Toolkit::ControlRenderer GetControlRenderer( const Vector4& color );
-
- /**
- * @copydoc Toolkit::RendererFactory::ResetRenderer( Toolkit::ControlRenderer&, Actor& actor, const Vector4& )
- */
- void ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Vector4& color );
-
- /**
- * @copydoc Toolkit::RenderFactory::GetControlRenderer( float, const Vector4&, bool )
- */
- Toolkit::ControlRenderer GetControlRenderer( float borderSize, const Vector4& borderColor, bool antiAliasing );
-
- /**
- * @copydoc Toolkit::RenderFactory::GetControlRenderer( const Image& )
- */
- Toolkit::ControlRenderer GetControlRenderer( const Image& image );
-
- /**
- * @copydoc Toolkit::RendererFactory::ResetRenderer( Toolkit::ControlRenderer&, Actor& actor, const Image& )
- */
- void ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const Image& image );
-
- /**
- * @copydoc Toolkit::RenderFactory::GetControlRenderer( const std::string&, ImageDimensions )
- */
- Toolkit::ControlRenderer GetControlRenderer( const std::string& image, ImageDimensions size );
-
- /**
- * @copydoc Toolkit::RendererFactory::ResetRenderer( Toolkit::ControlRenderer&, Actor& actor, const std::string&, ImageDimensions )
- */
- void ResetRenderer( Toolkit::ControlRenderer& renderer, Actor& actor, const std::string& image, ImageDimensions size );
+ Toolkit::ControlRenderer CreateControlRenderer( const std::string& image, ImageDimensions size );
public:
/**
{
mShadowPlaneBg = shadowPlaneBackground;
- mShadowPlane = Toolkit::ImageView::New();
+ mShadowPlane = Toolkit::ImageView::New( mOutputImage );
mShadowPlane.SetName( "SHADOW_PLANE" );
mShadowPlane.SetParentOrigin(ParentOrigin::CENTER);
mShadowPlane.SetAnchorPoint(AnchorPoint::CENTER);
- mShadowPlane.SetImage(mOutputImage);
mShadowPlane.SetProperty( Toolkit::ImageView::Property::IMAGE, mShadowRenderShader );
SetShaderConstants();
#include <dali/devel-api/scripting/scripting.h>
#include <dali/integration-api/debug.h>
+// INTERNAL_INCLUDES
+#include <dali-toolkit/internal/controls/renderers/control-renderer-impl.h>
+
namespace //Unnamed namespace
{
void SuperBlurView::OnInitialize()
{
mBlurStrengthPropertyIndex = Self().RegisterProperty( "blurStrength", 0.f );
-
- Property::Map rendererMap;
- rendererMap.Insert( "rendererType", "image");
-
- Property::Map shaderMap;
- std::stringstream verterShaderString;
- shaderMap[ "fragmentShader" ] = FRAGMENT_SHADER;
- rendererMap.Insert( "shader", shaderMap );
-
- Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
- for(unsigned int i=0; i<=mBlurLevels; i++)
- {
- mRenderers[i] = rendererFactory.GetControlRenderer( rendererMap );
- mRenderers[i].SetDepthIndex(i);
- }
}
void SuperBlurView::SetImage(Image inputImage)
ClearBlurResource();
mInputImage = inputImage;
- Actor self = Self();
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderers[0], self, mInputImage );
+ Actor self( Self() );
+ InitializeControlRenderer( self, mRenderers[0], mInputImage );
+ mRenderers[0].SetDepthIndex(0);
+ SetShaderEffect( mRenderers[0] );
+ if( self.OnStage() )
+ {
+ mRenderers[0].SetOnStage( self );
+ }
BlurImage( 0, inputImage);
for(unsigned int i=1; i<mBlurLevels;i++)
mResourcesCleared = true;
}
}
+void SuperBlurView::SetShaderEffect( Toolkit::ControlRenderer& renderer )
+{
+ Property::Map shaderMap;
+ std::stringstream verterShaderString;
+ shaderMap[ "fragmentShader" ] = FRAGMENT_SHADER;
+
+ Internal::ControlRenderer& rendererImpl = GetImplementation( renderer );
+ rendererImpl.SetCustomShader( shaderMap );
+}
void SuperBlurView::OnSizeSet( const Vector3& targetSize )
{
Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
Actor self = Self();
- for(unsigned int i=1; i<=mBlurLevels;i++)
+ for( unsigned int i = 1; i <= mBlurLevels; i++ )
{
float exponent = static_cast<float>(i);
mBlurredImage[i-1] = FrameBufferImage::New( mTargetSize.width/std::pow(2.f,exponent) , mTargetSize.height/std::pow(2.f,exponent),
GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, Dali::Image::NEVER );
- rendererFactory.ResetRenderer( mRenderers[i], self, mBlurredImage[i-1] );
+ InitializeControlRenderer( self, mRenderers[i], mBlurredImage[i - 1] );
+ mRenderers[ i ].SetDepthIndex( i );
+ SetShaderEffect( mRenderers[ i ] );
}
if( mInputImage )
if( self.OnStage() )
{
- for(unsigned int i=0; i<=mBlurLevels;i++)
+ for( unsigned int i = 1; i <= mBlurLevels; i++ )
{
mRenderers[i].SetOnStage( self );
}
}
Actor self = Self();
- mRenderers[0].SetOnStage( self );
+ if( mRenderers[0] )
+ {
+ mRenderers[0].SetOnStage( self );
+ }
for(unsigned int i=1; i<=mBlurLevels;i++)
{
- mRenderers[i].SetOnStage( self );
+ if( mRenderers[i] )
+ {
+ mRenderers[i].SetOnStage( self );
+ }
Renderer renderer = self.GetRendererAt( i );
Property::Index index = renderer.RegisterProperty( ALPHA_UNIFORM_NAME, 0.f );
*/
void ClearBlurResource();
+ /**
+ * Sets shader effect on the control renderer
+ * @param[in,out] Sets custom shader effect on the given renderer
+ */
+ void SetShaderEffect( Toolkit::ControlRenderer& renderer );
+
private:
std::vector<Toolkit::GaussianBlurView> mGaussianBlurView;
std::vector<FrameBufferImage> mBlurredImage;
{
mPropertyMap = map;
- Actor self = Self();
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mPropertyMap );
+ Actor self( Self() );
+ InitializeControlRenderer( self, mRenderer, mPropertyMap );
Property::Value* widthValue = mPropertyMap.Find( "width" );
if( widthValue )
void VideoView::SetNativeImageTarget()
{
- Actor self = Self();
+ Actor self( Self() );
int curPos = mVideoPlayer.GetPlayPosition();
mSetRenderingTarget = true;
mVideoPlayer.SetUrl( mUrl );
mVideoPlayer.FinishedSignal().Connect( this, &VideoView::EmitSignalFinish );
- Toolkit::RendererFactory::Get().ResetRenderer( mRenderer, self, mNativeImage );
+ InitializeControlRenderer( self, mRenderer, mNativeImage );
if( mIsPlay )
{
#include <dali/devel-api/rendering/renderer.h>
#include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
-// INTERNAL INCLUDES
-
namespace Dali
{
rendererMap.Insert( "shader", customShader );
// create actor to render input with applied emboss effect
- mActorForInput1 = Toolkit::ImageView::New( mInputImage );
+ mActorForInput1 = Toolkit::ImageView::New(mInputImage);
mActorForInput1.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput1.SetSize(mTargetSize);
Vector2 textureScale( 1.5f/mTargetSize.width, 1.5f/mTargetSize.height);
mActorForInput1.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap );
mRootActor.Add( mActorForInput1 );
- mActorForInput2 = Toolkit::ImageView::New( mInputImage );
+ mActorForInput2 = Toolkit::ImageView::New(mInputImage);
mActorForInput2.SetParentOrigin( ParentOrigin::CENTER );
mActorForInput2.SetSize(mTargetSize);
mActorForInput2.RegisterProperty( TEX_SCALE_UNIFORM_NAME, textureScale );
customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE;
rendererMap[ "shader"] = customShader;
- Toolkit::RendererFactory rendererFactory = Toolkit::RendererFactory::Get();
- mRendererForEmboss1 = rendererFactory.GetControlRenderer( mImageForEmboss1 );
- mRendererForEmboss2 = rendererFactory.GetControlRenderer( mImageForEmboss2 );
- // set COMPOSITE custom shader to both renderers
- rendererFactory.ResetRenderer( mRendererForEmboss1, mActorForComposite, rendererMap);
- rendererFactory.ResetRenderer( mRendererForEmboss2, mActorForComposite, rendererMap);
- // apply renderers to the actor
- mRendererForEmboss1.SetOnStage( mActorForComposite );
- mRendererForEmboss2.SetOnStage( mActorForComposite );
+ rendererMap[ "rendererType"] = "image";
+
+ mRootActor.Add( mActorForComposite );
+
+ InitializeControlRenderer( mActorForComposite, mRendererForEmboss1, rendererMap );
+ InitializeControlRenderer( mActorForComposite, mRendererForEmboss2, rendererMap );
+
+ TextureSet textureSet1 = TextureSet::New();
+ textureSet1.SetImage( 0, mImageForEmboss1 );
+ mActorForComposite.GetRendererAt(0).SetTextures( textureSet1 );
mActorForComposite.GetRendererAt(0).RegisterProperty( COLOR_UNIFORM_NAME, Color::BLACK );
+
+ TextureSet textureSet2 = TextureSet::New();
+ textureSet2.SetImage( 0, mImageForEmboss2 );
+ mActorForComposite.GetRendererAt(1).SetTextures( textureSet2 );
mActorForComposite.GetRendererAt(1).RegisterProperty( COLOR_UNIFORM_NAME, Color::WHITE );
- mRootActor.Add( mActorForComposite );
SetupCamera();
CreateRenderTasks();
#include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
#include <dali-toolkit/internal/styling/style-manager-impl.h>
#include <dali-toolkit/internal/controls/renderers/color/color-renderer.h>
+#include <dali-toolkit/internal/controls/renderers/renderer-string-constants.h>
namespace Dali
{
void Control::SetBackgroundColor( const Vector4& color )
{
- mImpl->mBackgroundColor = color;
-
Actor self( Self() );
- Toolkit::RendererFactory factory = Toolkit::RendererFactory::Get();
- factory.ResetRenderer( mImpl->mBackgroundRenderer, self, color );
- mImpl->mBackgroundRenderer.SetDepthIndex( DepthIndex::BACKGROUND );
+ mImpl->mBackgroundColor = color;
+ Property::Map map;
+ map[ RENDERER_TYPE ] = COLOR_RENDERER;
+ map[ "mixColor" ] = color;
+ InitializeControlRenderer( self, mImpl->mBackgroundRenderer, map );
+ if( mImpl->mBackgroundRenderer )
+ {
+ mImpl->mBackgroundRenderer.SetDepthIndex( DepthIndex::BACKGROUND );
+ }
}
Vector4 Control::GetBackgroundColor() const
return mImpl->mBackgroundColor;
}
-void Control::SetBackground(const Property::Map& map)
+void Control::SetBackground( const Property::Map& map )
{
Actor self( Self() );
- mImpl->mBackgroundRenderer.RemoveAndReset( self );
- Toolkit::RendererFactory factory = Toolkit::RendererFactory::Get();
- mImpl->mBackgroundRenderer = factory.GetControlRenderer( map );
- if( mImpl->mBackgroundRenderer && self.OnStage() ) // Request control renderer with a property map might return an empty handle
+ InitializeControlRenderer( self, mImpl->mBackgroundRenderer, map );
+ if( mImpl->mBackgroundRenderer )
{
mImpl->mBackgroundRenderer.SetDepthIndex( DepthIndex::BACKGROUND );
- mImpl->mBackgroundRenderer.SetOnStage( self );
}
}
void Control::SetBackgroundImage( Image image )
{
Actor self( Self() );
- Toolkit::RendererFactory factory = Toolkit::RendererFactory::Get();
- factory.ResetRenderer( mImpl->mBackgroundRenderer, self, image );
- mImpl->mBackgroundRenderer.SetDepthIndex( DepthIndex::BACKGROUND );
+ InitializeControlRenderer( self, mImpl->mBackgroundRenderer, image );
+ if( mImpl->mBackgroundRenderer )
+ {
+ mImpl->mBackgroundRenderer.SetDepthIndex( DepthIndex::BACKGROUND );
+ }
}
void Control::ClearBackground()
projects / platform / core / uifw / dali-toolkit.git / commitdiff