return time;
}
-static Image CreateSolidColorImage( ToolkitTestApplication& application, const Vector4& color, unsigned int width, unsigned int height )
+static Texture CreateSolidColorTexture( ToolkitTestApplication& application, const Vector4& color, unsigned int width, unsigned int height )
{
- BufferImage imageData = BufferImage::New( width, height, Pixel::RGBA8888 );
-
- // Create the image
- PixelBuffer* pixbuf = imageData.GetBuffer();
- unsigned int size = width * height;
-
- for( size_t i = 0; i < size; i++ )
- {
- pixbuf[i*4+0] = 0xFF * color.r;
- pixbuf[i*4+1] = 0xFF * color.g;
- pixbuf[i*4+2] = 0xFF * color.b;
- pixbuf[i*4+3] = 0xFF * color.a;
- }
- imageData.Update();
-
- application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
- application.SendNotification();
- application.Render(RENDER_FRAME_INTERVAL);
- application.Render(RENDER_FRAME_INTERVAL);
- application.SendNotification();
-
- return imageData;
+ Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ return texture;
}
}//namespace
DALI_TEST_CHECK( !emitter );
// Test object creation
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
DALI_TEST_CHECK( emitter );
tet_infoline(" UtcDaliBubbleEmitterDownCast01 ");
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
BaseHandle handle(emitter);
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterGetRootActor " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 270, Vector2( 5.f, 10.f ));
Actor root = emitter.GetRootActor();
DALI_TEST_CHECK( root );
- DALI_TEST_CHECK( root.GetChildCount() == 3 );
+ DALI_TEST_CHECK( root.GetChildCount() == 0 );
END_TEST;
}
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterSetBackground " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
unsigned int taskCount = taskList.GetTaskCount();
- Image bgImage = CreateSolidColorImage( application, Color::RED, 50, 50 );
+ Texture bgImage = CreateSolidColorTexture( application, Color::RED, 50, 50 );
emitter.SetBackground( bgImage, Vector3(0.f, 0.f, 0.5f) );
DALI_TEST_CHECK( taskList.GetTaskCount() == taskCount+1 );
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterSetBubbleScale " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 150, Vector2( 5.f, 10.f ));
DALI_TEST_CHECK(emitter);
Actor root = emitter.GetRootActor();
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterSetBubbleDensity " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
try
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterSetBubbleDensity " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
try
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterEmitBubble " );
- Image shapeImage1 = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
+ Texture shapeImage1 = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage1, 200, Vector2( 5.f, 10.f ));
Actor root = emitter.GetRootActor();
- Actor bubbleMesh = root.GetChildAt( 0 );
+ Renderer bubbleRenderer = root.GetRendererAt( 0 );
Stage::GetCurrent().Add( root );
- DALI_TEST_CHECK( bubbleMesh );
+ DALI_TEST_CHECK( bubbleRenderer );
- Property::Index propertyIndex0 = bubbleMesh.GetPropertyIndex( "uPercentage[0]" );
- Property::Index propertyIndex1 = bubbleMesh.GetPropertyIndex( "uPercentage[1]" );
+ Property::Index propertyIndex0 = bubbleRenderer.GetPropertyIndex( "uPercentage[0]" );
+ Property::Index propertyIndex1 = bubbleRenderer.GetPropertyIndex( "uPercentage[1]" );
float value0, value1;
Animation animation = Animation::New( 0.5f );
emitter.EmitBubble( animation, Vector2(40.f,40.f), Vector2(-5.f,-5.f), Vector2(30.f,30.f) );
emitter.EmitBubble( animation, Vector2(10.f,10.f), Vector2(5.f,5.f), Vector2(30.f,30.f) );
- (bubbleMesh.GetProperty(propertyIndex0)).Get( value0 );
- (bubbleMesh.GetProperty(propertyIndex1)).Get( value1 );
+ (bubbleRenderer.GetProperty(propertyIndex0)).Get( value0 );
+ (bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
DALI_TEST_EQUALS(value0, 0.f, TEST_LOCATION );
DALI_TEST_EQUALS(value1, 0.f, TEST_LOCATION );
animation.Play();
Wait(application, 300);
- propertyIndex0 = bubbleMesh.GetPropertyIndex( "uPercentage[0]" );
- propertyIndex1 = bubbleMesh.GetPropertyIndex( "uPercentage[1]" );
- (bubbleMesh.GetProperty(propertyIndex0)).Get( value0 );
- (bubbleMesh.GetProperty(propertyIndex1)).Get( value1 );
+ propertyIndex0 = bubbleRenderer.GetPropertyIndex( "uPercentage[0]" );
+ propertyIndex1 = bubbleRenderer.GetPropertyIndex( "uPercentage[1]" );
+ (bubbleRenderer.GetProperty(propertyIndex0)).Get( value0 );
+ (bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
DALI_TEST_CHECK( value0 >= 0.6f );
DALI_TEST_CHECK( value1 >= 0.6f );
Wait(application,500);
- (bubbleMesh.GetProperty(propertyIndex0)).Get( value0 );
- (bubbleMesh.GetProperty(propertyIndex1)).Get( value1 );
+ (bubbleRenderer.GetProperty(propertyIndex0)).Get( value0 );
+ (bubbleRenderer.GetProperty(propertyIndex1)).Get( value1 );
DALI_TEST_EQUALS(value0, 1.f, TEST_LOCATION );
DALI_TEST_EQUALS(value1, 1.f, TEST_LOCATION );
END_TEST;
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterRestore " );
- Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
- BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 90, Vector2( 5.f, 10.f ));
+ Vector2 movementArea(50.f,50.f);
+ Texture shapeImage = CreateSolidColorTexture( application, Color::GREEN, 5, 5 );
+ BubbleEmitter emitter = BubbleEmitter::New( movementArea,shapeImage, 90, Vector2( 5.f, 10.f ));
Actor root = emitter.GetRootActor();
Stage::GetCurrent().Add( root );
root.SetPosition( Vector3::ZERO );
root.SetParentOrigin( ParentOrigin::CENTER );
root.SetAnchorPoint( AnchorPoint::CENTER );
- Actor bubbleMesh = root.GetChildAt( 0 );
- Renderer renderer = bubbleMesh.GetRendererAt( 0 );
+ Renderer renderer = root.GetRendererAt( 0 );
DALI_TEST_CHECK( renderer );
TestGlAbstraction& gl = application.GetGlAbstraction();
DALI_TEST_EQUALS( percentageValue, 0.f, TEST_LOCATION );
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uStartEndPosition[0]", startEndPosValue ) );
- DALI_TEST_EQUALS( startEndPosValue.x, 40.f, TEST_LOCATION );
- DALI_TEST_EQUALS( startEndPosValue.y, 40.f, TEST_LOCATION );
+ DALI_TEST_EQUALS( startEndPosValue.x, 40.f - movementArea.x*0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS( startEndPosValue.y, 40.f- movementArea.x*0.5f, TEST_LOCATION );
animation.Play();
Wait(application, 200);
DALI_TEST_CHECK( percentageValue < 0.5f && percentageValue >= 0.4);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uStartEndPosition[0]", startEndPosValue ) );
- DALI_TEST_EQUALS( startEndPosValue.x, 40.f, TEST_LOCATION );
- DALI_TEST_EQUALS( startEndPosValue.y, 40.f, TEST_LOCATION );
+ DALI_TEST_EQUALS( startEndPosValue.x, 40.f- movementArea.x*0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS( startEndPosValue.y, 40.f- movementArea.x*0.5f, TEST_LOCATION );
emitter.Restore();
application.SendNotification();
}
BubbleEmitter BubbleEmitter::New( const Vector2& winSize,
- Image shapeImage,
+ Dali::Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange )
{
- return Internal::BubbleEmitter::New( winSize, shapeImage, maximumNumberOfBubble, bubbleSizeRange );
+ return Internal::BubbleEmitter::New( winSize, shapeTexture, maximumNumberOfBubble, bubbleSizeRange );
}
BubbleEmitter::BubbleEmitter( const BubbleEmitter& handle )
return GetImpl(*this).GetRootActor();
}
-void BubbleEmitter::SetBackground( Image bgImage, const Vector3& hsvDelta )
+void BubbleEmitter::SetBackground( Dali::Texture bgTexture, const Vector3& hsvDelta )
{
- GetImpl(*this).SetBackground( bgImage, hsvDelta );
+ GetImpl(*this).SetBackground( bgTexture, hsvDelta );
}
-void BubbleEmitter::SetShapeImage( Image shapeImage )
+void BubbleEmitter::SetBubbleShape( Dali::Texture shapeTexture )
{
- GetImpl(*this).SetShapeImage( shapeImage );
+ GetImpl(*this).SetBubbleShape( shapeTexture );
}
void BubbleEmitter::SetBubbleScale( float scale )
// INTERNAL INCLUDES
#include <dali-toolkit/public-api/controls/control.h>
+#include <dali/public-api/rendering/texture.h>
namespace Dali
{
* @brief Create an initialized BubbleEmitter.
*
* @param[in] winSize The size of the bubble moving area, usually the same size as the background.
- * @param[in] shapeImage The alpha channnel of this texture defines the bubble shape.
+ * @param[in] shapeTexture The alpha channnel of this texture defines the bubble shape.
* @param[in] maximumNumberOfBubble The maximum number of bubble needed.
* @param[in] bubbleSizeRange The size range of the bubbles; x component is the low bound, and y component is the up bound.
* @return The initialized BubbleEmitter object.
*/
static BubbleEmitter New( const Vector2& winSize,
- Image shapeImage,
+ Dali::Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange );
* @brief Set Background image.
*
* The bubbles pick color from this image with HSV values adjusted.
- * @param[in] bgImage The background image which provide color to bubbles.
+ * @param[in] bgTexture The background texture which provide color to bubbles.
* @param[in] hsvDelta The hsv channel difference used to adjust the background image color.
* If set these vector as Vector3::Zero, original colors are used.
*/
- void SetBackground( Image bgImage, const Vector3& hsvDelta );
+ void SetBackground( Dali::Texture bgTexture, const Vector3& hsvDelta );
/**
* @brief Set bubble shape.
*
- * The bubble mesh is a rectangular patch, but its displayed shape is decided by the alpha channel of the shape image.
- * @param[in] shapeImage The image whose alpha channel defines the bubble shape.
+ * The bubble mesh is a rectangular patch, but its displayed shape is decided by the alpha channel of the shape texture.
+ * @param[in] shapeTexture The texture whose alpha channel defines the bubble shape.
*/
- void SetShapeImage( Image shapeImage );
+ void SetBubbleShape( Dali::Texture shapeTexture );
/**
* @brief Set the scale factor applied to all the bubbles.
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include "bubble-actor.h"
-
-// EXTERNAL INCLUDES
-#include <cmath>
-#include <sstream>
-
-// INTERNAL INCLUDES
-
-namespace Dali
-{
-
-namespace Toolkit
-{
-
-namespace Internal
-{
-
-BubbleActor::BubbleActor( unsigned int numberOfBubble,
- const Vector2& movementArea)
-: mActor(),
- mRenderer(),
- mMovementArea( movementArea ),
- mIndicesOffset(),
- mIndiceStartEndPos(),
- mIndicesPercentage(),
- mIndexGravity( Property::INVALID_INDEX ),
- mIndexDynamicScale( Property::INVALID_INDEX ),
- mIndexInvertedMovementArea( Property::INVALID_INDEX ),
- mNumBubble( numberOfBubble ),
- mRandomSeed( 0 )
-{
- mActor = Actor::New();
-}
-
-void BubbleActor::MakeRenderable( Geometry geometry, TextureSet textureSet, Shader shader )
-{
- if( mRenderer )
- {
- // This function is supposed to be called once
- return;
- }
-
- mRenderer = Renderer::New( geometry, shader );
- mRenderer.SetTextures( textureSet );
-
- mActor.AddRenderer( mRenderer );
- mActor.SetSize( mMovementArea );
- mActor.SetParentOrigin(ParentOrigin::TOP_LEFT);
-
- // register uniforms
- mIndexGravity = mActor.RegisterProperty( "uGravity", 50.f );
- mIndexDynamicScale = mActor.RegisterProperty( "uDynamicScale", 1.f );
-
- mIndexInvertedMovementArea = mActor.RegisterProperty( "uInvertedMovementArea", Vector2(1.f,1.f) / mMovementArea );
-
- mIndicesOffset.resize(9);
- int offset = mMovementArea.Length() / 10.f;
-
- mRandomSeed = time( NULL );
-
- mIndicesOffset[0] = mActor.RegisterProperty( "uOffset[0]", Vector2( 0.f,0.f ) );
- mIndicesOffset[1] = mActor.RegisterProperty( "uOffset[1]", Vector2( rand_r( &mRandomSeed ) % offset, rand_r( &mRandomSeed ) % offset ) );
- mIndicesOffset[2] = mActor.RegisterProperty( "uOffset[2]", Vector2( rand_r( &mRandomSeed ) % offset, -rand_r( &mRandomSeed ) % offset ) );
- mIndicesOffset[3] = mActor.RegisterProperty( "uOffset[3]", Vector2(-rand_r( &mRandomSeed ) % offset, rand_r( &mRandomSeed ) % offset ) );
- mIndicesOffset[4] = mActor.RegisterProperty( "uOffset[4]", Vector2(-rand_r( &mRandomSeed ) % offset, -rand_r( &mRandomSeed ) % offset ) );
- mIndicesOffset[5] = mActor.RegisterProperty( "uOffset[5]", Vector2( rand_r( &mRandomSeed ) % offset, 0.f ) );
- mIndicesOffset[6] = mActor.RegisterProperty( "uOffset[6]", Vector2(-rand_r( &mRandomSeed ) % offset, 0.f ) );
- mIndicesOffset[7] = mActor.RegisterProperty( "uOffset[7]", Vector2( 0.f, rand_r( &mRandomSeed ) % offset ) );
- mIndicesOffset[8] = mActor.RegisterProperty( "uOffset[8]", Vector2( 0.f, -rand_r( &mRandomSeed ) % offset ) );
-
- Vector4 zeroVector;
- mIndiceStartEndPos.resize( mNumBubble );
- mIndicesPercentage.resize( mNumBubble );
- for( unsigned int i=0; i<mNumBubble; i++ )
- {
- std::ostringstream ossProperty;
- ossProperty<< "uStartEndPosition["<< i << "]";
- mIndiceStartEndPos[i] = mActor.RegisterProperty( ossProperty.str(), zeroVector );
-
- ossProperty.str("");
- ossProperty<< "uPercentage["<< i << "]";
- mIndicesPercentage[i] = mActor.RegisterProperty( ossProperty.str(), 0.f );
- }
-}
-
-Actor BubbleActor::GetMeshActor()
-{
- return mActor;
-}
-
-void BubbleActor::SetGeometry( Geometry geometry )
-{
- mRenderer.SetGeometry( geometry );
-}
-
-void BubbleActor::SetMovementArea( const Vector2& movementArea )
-{
- if( movementArea == mMovementArea)
- {
- return;
- }
-
- mMovementArea = movementArea;
- mActor.SetSize( mMovementArea );
- mActor.SetProperty( mIndexInvertedMovementArea, Vector2(1.f,1.f) / mMovementArea );
-
- int offset = mMovementArea.Length() / 10.f;
-
- mActor.SetProperty( mIndicesOffset[1], Vector2( rand_r( &mRandomSeed ) % offset, rand_r( &mRandomSeed ) % offset ) );
- mActor.SetProperty( mIndicesOffset[2], Vector2( rand_r( &mRandomSeed ) % offset, -rand_r( &mRandomSeed ) % offset ) );
- mActor.SetProperty( mIndicesOffset[3], Vector2(-rand_r( &mRandomSeed ) % offset, rand_r( &mRandomSeed ) % offset ) );
- mActor.SetProperty( mIndicesOffset[4], Vector2(-rand_r( &mRandomSeed ) % offset, -rand_r( &mRandomSeed ) % offset ) );
- mActor.SetProperty( mIndicesOffset[5], Vector2( rand_r( &mRandomSeed ) % offset, 0.f ) );
- mActor.SetProperty( mIndicesOffset[6], Vector2(-rand_r( &mRandomSeed ) % offset, 0.f ) );
- mActor.SetProperty( mIndicesOffset[7], Vector2( 0.f, rand_r( &mRandomSeed ) % offset ) );
- mActor.SetProperty( mIndicesOffset[8], Vector2( 0.f, -rand_r( &mRandomSeed ) % offset ) );
-}
-
-void BubbleActor::SetStartAndEndPosition( unsigned int index, const Vector4& startAndEndPosition )
-{
- mActor.SetProperty( mIndiceStartEndPos[index], startAndEndPosition );
-}
-
-void BubbleActor::SetPercentage( unsigned int index, float percentage )
-{
- mActor.SetProperty( mIndicesPercentage[index], percentage );
-}
-
-void BubbleActor::SetGravity( float gravity )
-{
- mActor.SetProperty( mIndexGravity, gravity );
-}
-
-void BubbleActor::SetDynamicScale( float scale )
-{
- mActor.SetProperty( mIndexDynamicScale, scale );
-}
-
-Property BubbleActor::GetPercentageProperty( unsigned int index )
-{
- return Property( mActor, mIndicesPercentage[index] );
-}
-
-void BubbleActor::ResetProperties()
-{
- Vector4 zeroVector;
- for( unsigned int i=0; i<mNumBubble; i++ )
- {
- SetPercentage( i, 0.f);
- SetStartAndEndPosition( i, zeroVector );
- }
-}
-
-} // namespace Internal
-
-} // namespace Toolkit
-
-} // namespace Dali
vTexCoord = aTexCoord;\n
vPercentage = percentage;\n
// Use the emit position color for the bubble
- vEffectTexCoord = startAndEnd.xy * uInvertedMovementArea;\n
+ vEffectTexCoord = startAndEnd.xy * uInvertedMovementArea + vec2(0.5);\n
}\n
);
// EXTERNAL INCLUDES
#include <dali/public-api/animation/animation.h>
#include <dali/public-api/render-tasks/render-task-list.h>
-#include <dali/public-api/images/resource-image.h>
-#include <dali/devel-api/images/texture-set-image.h>
+#include <dali/public-api/rendering/texture.h>
+#include <dali/public-api/rendering/shader.h>
// INTERNAL INCLUDES
-#include <dali-toolkit/internal/controls/bubble-effect/bubble-actor.h>
-#include <dali-toolkit/internal/controls/bubble-effect/color-adjuster.h>
#include <dali-toolkit/internal/controls/bubble-effect/bubble-effect.h>
-#include <dali-toolkit/public-api/controls/image-view/image-view.h>
-
+#include <dali-toolkit/internal/controls/bubble-effect/bubble-renderer.h>
namespace
{
return f0 + (rand_r( &seed ) & 0xfff) * (f1-f0) * (1.0f/4095.0f);
}
+const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
+ attribute mediump vec2 aPosition;\n
+ attribute mediump vec2 aTexCoord;\n
+ uniform mediump vec3 uSize;\n
+ uniform mediump mat4 uMvpMatrix;\n
+ varying mediump vec2 vTexCoord;\n
+ \n
+
+ void main()\n
+ {\n
+ gl_Position = uMvpMatrix * vec4(aPosition*uSize.xy,0.0,1.0);
+ vTexCoord = aTexCoord;\n
+ }\n
+);
+
+const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
+ precision highp float;\n
+ uniform vec3 uHSVDelta;\n
+ varying mediump vec2 vTexCoord;\n
+ uniform sampler2D sTexture;\n
+ float rand(vec2 co) \n
+ {\n
+ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); \n}
+ \n
+ vec3 rgb2hsv(vec3 c)\n
+ {\n
+ vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n
+ vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));\n
+ vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));\n
+ \n
+ float d = q.x - min(q.w, q.y);\n
+ float e = 1.0e-10;\n
+ return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n
+ }\n
+ vec3 hsv2rgb(vec3 c)\n
+ {\n
+ vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n
+ vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);\n
+ return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);\n
+ }\n
+ void main() {\n
+ vec4 color = texture2D(sTexture, vTexCoord); \n
+ vec3 hsvColor = rgb2hsv( color.rgb );\n
+ // modify the hsv Value
+ hsvColor += uHSVDelta * rand(vTexCoord); \n
+ // if the new vale exceeds one, then decrease it
+ hsvColor -= max(hsvColor*2.0 - vec3(2.0), 0.0);\n
+ // if the new vale drops below zero, then increase it
+ hsvColor -= min(hsvColor*2.0, 0.0);\n
+ color = vec4( hsv2rgb( hsvColor ), 1.0 ); \n
+ gl_FragColor = color; \n
+ }\n
+ );
+
+Dali::Geometry CreateTexturedQuad()
+{
+ struct Vertex
+ {
+ Dali::Vector2 position;
+ Dali::Vector2 texCoord;
+ };
+
+ static const Vertex data[] = {{ Dali::Vector2( -0.5f, -0.5f ), Dali::Vector2( 0.0f, 0.0f ) },
+ { Dali::Vector2( 0.5f, -0.5f ), Dali::Vector2( 1.0f, 0.0f ) },
+ { Dali::Vector2( -0.5f, 0.5f ), Dali::Vector2( 0.0f, 1.0f ) },
+ { Dali::Vector2( 0.5f, 0.5f ), Dali::Vector2( 1.0f, 1.0f ) }};
+
+ //Create a vertex buffer for vertex positions and texture coordinates
+ Dali::PropertyBuffer vertexBuffer = Dali::PropertyBuffer::New( Dali::Property::Map()
+ .Add( "aPosition", Dali::Property::VECTOR2 )
+ .Add( "aTexCoord", Dali::Property::VECTOR2 ) );
+ vertexBuffer.SetData( data, 4u );
+
+ //Create the geometry
+ Dali::Geometry geometry = Dali::Geometry::New();
+ geometry.AddVertexBuffer( vertexBuffer );
+ geometry.SetType(Dali::Geometry::TRIANGLE_STRIP );
+
+ return geometry;
+}
+
}
namespace Dali
namespace Internal
{
BubbleEmitter::BubbleEmitter( const Vector2& movementArea,
- Image shapeImage,
+ Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange )
: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ),
- mShapeImage( shapeImage ),
+ mShapeTexture( shapeTexture ),
mMovementArea( movementArea ),
mBubbleSizeRange( bubbleSizeRange ),
mDensity( 5 ),
// Calculate how many shaders are required
if( mTotalNumOfBubble>100 )
{
- mNumBubblePerActor = 100;
- mNumActor = mTotalNumOfBubble / 100;
- if( mNumActor*mNumBubblePerActor < mTotalNumOfBubble )
+ mNumBubblePerRenderer = 100;
+ mNumRenderer = mTotalNumOfBubble / 100;
+ if( mNumRenderer*mNumBubblePerRenderer < mTotalNumOfBubble )
{
- mNumActor++;
- mNumBubblePerActor = mTotalNumOfBubble / mNumActor+1;
- mTotalNumOfBubble = mNumActor * mNumBubblePerActor;
+ mNumRenderer++;
+ mNumBubblePerRenderer = mTotalNumOfBubble / mNumRenderer+1;
+ mTotalNumOfBubble = mNumRenderer * mNumBubblePerRenderer;
}
}
else
{
- mNumBubblePerActor = mTotalNumOfBubble;
- mNumActor = 1;
+ mNumBubblePerRenderer = mTotalNumOfBubble;
+ mNumRenderer = 1;
}
mRandomSeed = time( NULL );
}
Toolkit::BubbleEmitter BubbleEmitter::New( const Vector2& winSize,
- Image shapeImage,
+ Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange )
{
// Create the implementation
- IntrusivePtr<BubbleEmitter> internalBubbleEmitter ( new BubbleEmitter( winSize, shapeImage,
+ IntrusivePtr<BubbleEmitter> internalBubbleEmitter ( new BubbleEmitter( winSize, shapeTexture,
maximumNumberOfBubble,bubbleSizeRange ) );
// Pass ownership to Toolkit::BubbleEmitter handle
mBubbleRoot = Actor::New();
mBubbleRoot.SetSize(mMovementArea);
- // Prepare the frame buffer to store the color adjusted background image
- mEffectImage = FrameBufferImage::New( mMovementArea.width/4.f, mMovementArea.height/4.f, Pixel::RGBA8888 );
+ // Prepare the frame buffer to store the color adjusted background texture
+ Vector2 imageSize = Vector2( mMovementArea.width/4.f, mMovementArea.height/4.f );
+ mFrameBuffer = FrameBuffer::New( imageSize.x, imageSize.y, 0 );
+ mEffectTexture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, imageSize.x, imageSize.y );
+ mFrameBuffer.AttachColorTexture( mEffectTexture );
// Generate the geometry, which is used by all bubbleActors
- mMeshGeometry = CreateGeometry( mNumBubblePerActor*mDensity );
+ mMeshGeometry = CreateGeometry( mNumBubblePerRenderer*mDensity );
- Shader bubbleShader = CreateBubbleShader (mNumBubblePerActor );
+ Shader bubbleShader = CreateBubbleShader( mNumBubblePerRenderer );
mTextureSet = TextureSet::New();
- TextureSetImage( mTextureSet, 0u, mEffectImage );
- TextureSetImage( mTextureSet, 1u, mShapeImage );
-
- mBubbleActors.resize( mNumActor );
+ mTextureSet.SetTexture( 0u, mEffectTexture );
+ mTextureSet.SetTexture( 1u, mShapeTexture );
- // Create the meshActor group and bubbleEffect group to emit bubbles following the given track, such as finger touch track.
- for(unsigned int i=0; i < mNumActor; i++ )
+ // Create the renderers to render the bubbles
+ mBubbleRenderers.resize( mNumRenderer );
+ for(unsigned int i=0; i < mNumRenderer; i++ )
{
- mBubbleActors[i] = new BubbleActor( mNumBubblePerActor, mMovementArea );
- (mBubbleActors[i])->MakeRenderable( mMeshGeometry, mTextureSet, bubbleShader );
- mBubbleRoot.Add( (mBubbleActors[i])->GetMeshActor() );
+ mBubbleRenderers[i].Initialize( mNumBubblePerRenderer, mMovementArea, mMeshGeometry, mTextureSet, bubbleShader );
+ mBubbleRoot.AddRenderer( mBubbleRenderers[i].GetRenderer() );
}
// Create a cameraActor for the off screen render task.
return mBubbleRoot;
}
-void BubbleEmitter::SetBackground( Image bgImage, const Vector3& hsvDelta )
+void BubbleEmitter::SetBackground( Texture bgTexture, const Vector3& hsvDelta )
{
- mBackgroundImage = bgImage;
+ mBackgroundTexture = bgTexture;
mHSVDelta = hsvDelta;
- Toolkit::ImageView sourceActor = Toolkit::ImageView::New(bgImage);
+ //Create RenderTask source actor
+ Actor sourceActor = Actor::New();
sourceActor.SetSize( mMovementArea );
sourceActor.SetParentOrigin(ParentOrigin::CENTER);
-
- Property::Map colorAdjuster = CreateColorAdjuster();
- sourceActor.SetProperty( Toolkit::ImageView::Property::IMAGE, colorAdjuster);
- SetColorAdjusterProperties( sourceActor, hsvDelta, true /*ignore alpha to make bubble color always*/ );
-
+ sourceActor.RegisterProperty( "uHSVDelta", hsvDelta );
Stage::GetCurrent().Add( sourceActor );
+ //Create renderer
+ Dali::Geometry geometry = CreateTexturedQuad();
+ Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
+ Renderer renderer = Renderer::New( geometry, shader );
+ TextureSet textureSet = TextureSet::New();
+ textureSet.SetTexture(0u, bgTexture );
+ renderer.SetTextures( textureSet );
+ sourceActor.AddRenderer( renderer );
+
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
RenderTask task = taskList.CreateTask();
task.SetRefreshRate( RenderTask::REFRESH_ONCE );
task.SetExclusive(true);
task.SetCameraActor(mCameraActor);
task.GetCameraActor().SetInvertYAxis(true);
- task.SetTargetFrameBuffer( mEffectImage );
+ task.SetFrameBuffer( mFrameBuffer );
task.FinishedSignal().Connect(this, &BubbleEmitter::OnRenderFinished);
mRenderTaskRunning = true;
}
-void BubbleEmitter::SetShapeImage( Image shapeImage )
+void BubbleEmitter::SetBubbleShape( Texture shapeTexture )
{
- TextureSetImage( mTextureSet, 1, shapeImage );
+ mTextureSet.SetTexture( 1, shapeTexture );
}
void BubbleEmitter::SetBubbleScale( float scale )
{
- for(unsigned int i=0; i < mNumActor; i++ )
+ for(unsigned int i=0; i < mNumRenderer; i++ )
{
- (mBubbleActors[i])->SetDynamicScale( scale );
+ mBubbleRenderers[i].SetDynamicScale( scale );
}
}
else
{
mDensity = density;
- mMeshGeometry = CreateGeometry( mNumBubblePerActor*mDensity );
- for(unsigned int i=0; i < mNumActor; i++ )
+ mMeshGeometry = CreateGeometry( mNumBubblePerRenderer*mDensity );
+ for(unsigned int i=0; i < mNumRenderer; i++ )
{
- (mBubbleActors[i])->SetGeometry( mMeshGeometry );
+ mBubbleRenderers[i].SetGeometry( mMeshGeometry );
}
}
}
// and trigger re-draw if not already running
if( ! mRenderTaskRunning )
{
- SetBackground( mBackgroundImage, mHSVDelta );
+ SetBackground( mBackgroundTexture, mHSVDelta );
}
}
void BubbleEmitter::EmitBubble( Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement )
{
- unsigned int curUniform = mCurrentBubble % mNumBubblePerActor;
- unsigned int groupIdx = mCurrentBubble / mNumBubblePerActor;
- SetBubbleParameter( mBubbleActors[groupIdx], curUniform, emitPosition, direction, displacement);
- animation.AnimateTo( (mBubbleActors[groupIdx])->GetPercentageProperty(curUniform),
+ unsigned int curUniform = mCurrentBubble % mNumBubblePerRenderer;
+ unsigned int groupIdx = mCurrentBubble / mNumBubblePerRenderer;
+ SetBubbleParameter( mBubbleRenderers[groupIdx], curUniform, emitPosition - Vector2(mMovementArea.x*0.5f,mMovementArea.y*0.5f), direction, displacement);
+ animation.AnimateTo( mBubbleRenderers[groupIdx].GetPercentageProperty(curUniform),
1.f, AlphaFunction::LINEAR );
mCurrentBubble = (mCurrentBubble + 1) % mTotalNumOfBubble;
void BubbleEmitter::Restore()
{
- for(unsigned int i=0; i < mNumActor; i++ )
+ for(unsigned int i=0; i < mNumRenderer; i++ )
{
- (mBubbleActors[i])->ResetProperties();
+ mBubbleRenderers[i].ResetProperties();
}
}
Geometry BubbleEmitter::CreateGeometry( unsigned int numOfPatch )
{
unsigned int numVertex = numOfPatch*4u;
- std::vector<Vertex> vertexData;
- vertexData.reserve( numVertex );
+ Vector<Vertex> vertexData;
+ vertexData.Reserve( numVertex );
unsigned int numIndex = numOfPatch*6u;
Vector<unsigned short> indexData;
for(unsigned int i = 0; i < numOfPatch; i++)
{
- float curSize = RandomRange(mBubbleSizeRange.x, mBubbleSizeRange.y, mRandomSeed);
+ float halfSize = RandomRange(mBubbleSizeRange.x, mBubbleSizeRange.y, mRandomSeed) * 0.5f;
float index = static_cast<float>( i );
- vertexData.push_back( Vertex( index, Vector2(0.f,0.f), Vector2(0.f,0.f) ) );
- vertexData.push_back( Vertex( index, Vector2(0.f,curSize), Vector2(0.f,1.f) ) );
- vertexData.push_back( Vertex( index, Vector2(curSize,curSize), Vector2(1.f,1.f) ) );
- vertexData.push_back( Vertex( index, Vector2(curSize,0.f), Vector2(1.f,0.f) ) );
+ vertexData.PushBack( Vertex( index, Vector2(-halfSize,-halfSize),Vector2(0.f,0.f) ) );
+ vertexData.PushBack( Vertex( index, Vector2(-halfSize, halfSize), Vector2(0.f,1.f) ) );
+ vertexData.PushBack( Vertex( index, Vector2( halfSize, halfSize), Vector2(1.f,1.f) ) );
+ vertexData.PushBack( Vertex( index, Vector2( halfSize,-halfSize), Vector2(1.f,0.f) ) );
unsigned short idx = index * 4;
indexData.PushBack( idx );
return geometry;
}
-void BubbleEmitter::SetBubbleParameter( BubbleActorPtr bubbleActor, unsigned int curUniform,
+void BubbleEmitter::SetBubbleParameter( BubbleRenderer& bubbleRenderer, unsigned int curUniform,
const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement )
{
Vector2 dir(direction);
randomVec.y *= 0.33f;
}
Vector4 startAndEndPos( emitPosition.x, emitPosition.y, emitPosition.x+randomVec.x, emitPosition.y+randomVec.y );
- bubbleActor->SetStartAndEndPosition( curUniform, startAndEndPos );
+ bubbleRenderer.SetStartAndEndPosition( curUniform, startAndEndPos );
- bubbleActor->SetPercentage( curUniform, 0.f);
+ bubbleRenderer.SetPercentage( curUniform, 0.f);
}
} // namespace Internal
// EXTERNAL INCLUDES
#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/common/stage.h>
-#include <dali/public-api/images/frame-buffer-image.h>
+#include <dali/public-api/rendering/frame-buffer.h>
#include <dali/public-api/render-tasks/render-task.h>
#include <dali/public-api/rendering/geometry.h>
#include <dali/public-api/rendering/property-buffer.h>
namespace Internal
{
-class BubbleActor;
-typedef IntrusivePtr<BubbleActor> BubbleActorPtr;
+class BubbleRenderer;
/**
* BubbleEmitter implementation class.
* @copydoc Toolkit::BubbleEmitter::New
*/
static Toolkit::BubbleEmitter New( const Vector2& winSize,
- Image shapeImage,
+ Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange );
/**
* @copydoc Toolkit::BubbleEmitter::SetBackground
*/
- void SetBackground( Image bgImage, const Vector3& hsvDelta );
+ void SetBackground( Texture bgTexture, const Vector3& hsvDelta );
/**
- * @copydoc Toolkit::BubbleEmitter::SetShapeImage
+ * @copydoc Toolkit::BubbleEmitter::SetShape
*/
- void SetShapeImage( Image shapeImage );
+ void SetBubbleShape( Texture shapeTexture );
/**
* @copydoc Toolkit::BubbleEmiter::SetBubbleScale
/**
* Construct a new BubbleEmitter object.
* @param[in] movementArea The size of the bubble moving area
- * @param[in] shapeImage The alpha channnel of this texture defines the bubble shape.
+ * @param[in] shapeTexture The alpha channnel of this texture defines the bubble shape.
* @param[in] maximumNumberOfBubble The maximum number of bubble needed.
* @param[in] bubbleSizeRange The size range of the bubbles; x component is the minimal size, and y component is the maximum size.
*/
BubbleEmitter( const Vector2& movementArea,
- Image shapeImage,
+ Texture shapeTexture,
unsigned int maximumNumberOfBubble,
const Vector2& bubbleSizeRange );
/**
* Callback function of the finished signal of off-screen render task.
- * @param[in] source The render task used to create the color adjusted background image.
+ * @param[in] source The render task used to create the color adjusted background texture.
*/
void OnRenderFinished(RenderTask& source);
/**
* Set the uniform values to the shader effect to emit a bubble
- * @param[in] bubbleActor The BubbleActor to render the current bubble
+ * @param[in] bubbleRenderer The BubbleRenderer
* @param[in] curUniform The index of the uniform array in the shader
* @param[in] emitPosition The start position of the bubble movement.
* @param[in] direction The direction used to constrain the bubble to move in an adjacent direction around it.
* @param[in] displacement The displacement used to bound the moving distance of the bubble.
*/
- void SetBubbleParameter( BubbleActorPtr bubbleActor, unsigned int curUniform,
+ void SetBubbleParameter( BubbleRenderer& bubbleRenderer, unsigned int curUniform,
const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement );
private:
Actor mBubbleRoot; ///<The bubble root actor. Need to add it to stage to get the bubbles rendered.
- Image mShapeImage; ///< The alpha channnel of this texture defines the bubble shape.
- Image mBackgroundImage; ///< The original background image
- FrameBufferImage mEffectImage; ///< The image stores the adjusted color of the background image.The bubbles pick color from this image.
+ Texture mShapeTexture; ///< The alpha channnel of this texture defines the bubble shape.
+ Texture mBackgroundTexture; ///< The original background texture
+ Texture mEffectTexture; ///< Texture which stores the adjusted color of the background image.The bubbles pick color from this image.
+ FrameBuffer mFrameBuffer; ///< FrameBuffer used for offscreen rendering
CameraActor mCameraActor; ///< The render task views the scene from the perspective of this actor.
Geometry mMeshGeometry; ///< The mesh geometry which contains the vertices and indices data
TextureSet mTextureSet; ///< The texture set which controls the bubble display
- std::vector<BubbleActorPtr> mBubbleActors; ///< The meshActor vector, its size is mNumShader.
+ std::vector<BubbleRenderer> mBubbleRenderers; ///< The BubbleRenderer vector, its size is mNumShader.
Vector2 mMovementArea; ///< The size of the bubble moving area, usually the same size as the background.
Vector2 mBubbleSizeRange; ///< The size range of the bubbles; x component is the low bound, and y component is the up bound.
Vector3 mHSVDelta; ///< The HSV difference used to adjust the background image color.
- unsigned int mNumBubblePerActor; ///< How many bubbles for each BubbleActor.
- unsigned int mNumActor; ///< How many BubbleActors are used.
+ unsigned int mNumBubblePerRenderer; ///< How many bubbles for each BubbleRenderer.
+ unsigned int mNumRenderer; ///< How many BubbleRenderers are used.
unsigned int mDensity; ///< How many bubbles will emit at each time, they are controlled by same uniforms in the shader.
unsigned int mTotalNumOfBubble; ///< mNumBubblePerShader*mNumShader.
unsigned int mCurrentBubble; ///< Keep track of the index for the newly emitted bubble
--- /dev/null
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "bubble-renderer.h"
+
+// EXTERNAL INCLUDES
+#include <cmath>
+#include <sstream>
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+BubbleRenderer::BubbleRenderer()
+: mRenderer(),
+ mIndicesOffset(),
+ mIndiceStartEndPos(),
+ mIndicesPercentage(),
+ mIndexGravity( Property::INVALID_INDEX ),
+ mIndexDynamicScale( Property::INVALID_INDEX ),
+ mIndexInvertedMovementArea( Property::INVALID_INDEX )
+{
+}
+
+void BubbleRenderer::Initialize( unsigned int numberOfBubble, const Vector2& movementArea, Geometry geometry, TextureSet textureSet, Shader shader )
+{
+ if( mRenderer )
+ {
+ // This function is supposed to be called once
+ return;
+ }
+
+ mRenderer = Renderer::New( geometry, shader );
+ mRenderer.SetTextures( textureSet );
+
+ // register uniforms
+ mIndexGravity = mRenderer.RegisterProperty( "uGravity", 50.f );
+ mIndexDynamicScale = mRenderer.RegisterProperty( "uDynamicScale", 1.f );
+
+ mIndexInvertedMovementArea = mRenderer.RegisterProperty( "uInvertedMovementArea", Vector2(1.f,1.f) / movementArea );
+
+ mIndicesOffset.resize(9);
+ int offset = movementArea.Length() / 10.f;
+
+ unsigned int seed = time( NULL );
+
+ mIndicesOffset[0] = mRenderer.RegisterProperty( "uOffset[0]", Vector2( 0.f,0.f ) );
+ mIndicesOffset[1] = mRenderer.RegisterProperty( "uOffset[1]", Vector2( rand_r( &seed ) % offset, rand_r( &seed ) % offset ) );
+ mIndicesOffset[2] = mRenderer.RegisterProperty( "uOffset[2]", Vector2( rand_r( &seed ) % offset, -rand_r( &seed ) % offset ) );
+ mIndicesOffset[3] = mRenderer.RegisterProperty( "uOffset[3]", Vector2(-rand_r( &seed ) % offset, rand_r( &seed ) % offset ) );
+ mIndicesOffset[4] = mRenderer.RegisterProperty( "uOffset[4]", Vector2(-rand_r( &seed ) % offset, -rand_r( &seed ) % offset ) );
+ mIndicesOffset[5] = mRenderer.RegisterProperty( "uOffset[5]", Vector2( rand_r( &seed ) % offset, 0.f ) );
+ mIndicesOffset[6] = mRenderer.RegisterProperty( "uOffset[6]", Vector2(-rand_r( &seed ) % offset, 0.f ) );
+ mIndicesOffset[7] = mRenderer.RegisterProperty( "uOffset[7]", Vector2( 0.f, rand_r( &seed ) % offset ) );
+ mIndicesOffset[8] = mRenderer.RegisterProperty( "uOffset[8]", Vector2( 0.f, -rand_r( &seed ) % offset ) );
+
+ Vector4 zeroVector;
+ mIndiceStartEndPos.resize( numberOfBubble );
+ mIndicesPercentage.resize( numberOfBubble );
+ for( unsigned int i=0; i<numberOfBubble; i++ )
+ {
+ std::ostringstream ossProperty;
+ ossProperty<< "uStartEndPosition["<< i << "]";
+ mIndiceStartEndPos[i] = mRenderer.RegisterProperty( ossProperty.str(), zeroVector );
+
+ ossProperty.str("");
+ ossProperty<< "uPercentage["<< i << "]";
+ mIndicesPercentage[i] = mRenderer.RegisterProperty( ossProperty.str(), 0.f );
+ }
+}
+
+Renderer& BubbleRenderer::GetRenderer()
+{
+ return mRenderer;
+}
+
+void BubbleRenderer::SetGeometry( Geometry geometry )
+{
+ mRenderer.SetGeometry( geometry );
+}
+
+void BubbleRenderer::SetStartAndEndPosition( unsigned int index, const Vector4& startAndEndPosition )
+{
+ mRenderer.SetProperty( mIndiceStartEndPos[index], startAndEndPosition );
+}
+
+void BubbleRenderer::SetPercentage( unsigned int index, float percentage )
+{
+ mRenderer.SetProperty( mIndicesPercentage[index], percentage );
+}
+
+void BubbleRenderer::SetGravity( float gravity )
+{
+ mRenderer.SetProperty( mIndexGravity, gravity );
+}
+
+void BubbleRenderer::SetDynamicScale( float scale )
+{
+ mRenderer.SetProperty( mIndexDynamicScale, scale );
+}
+
+Property BubbleRenderer::GetPercentageProperty( unsigned int index )
+{
+ return Property( mRenderer, mIndicesPercentage[index] );
+}
+
+void BubbleRenderer::ResetProperties()
+{
+ Vector4 zeroVector;
+ for( unsigned int i=0; i<mIndicesPercentage.size(); i++ )
+ {
+ SetPercentage( i, 0.f);
+ SetStartAndEndPosition( i, zeroVector );
+ }
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
-#ifndef DALI_TOOLKIT_INTERNAL_BUBBLE_ACTOR_H
-#define DALI_TOOLKIT_INTERNAL_BUBBLE_ACTOR_H
+#ifndef DALI_TOOLKIT_INTERNAL_BUBBLE_RENDERER_H
+#define DALI_TOOLKIT_INTERNAL_BUBBLE_RENDERER_H
/*
* Copyright (c) 2016 Samsung Electronics Co., Ltd.
{
/**
- * BubbleActor is a group of bubbles.Each bubble can be moved separately.
+ * BubbleRenderer renders a group of bubbles.Each bubble can be moved separately.
* Its custom shader achieves similar effect of particle system by applying on a specially created mesh
* Each bubble is rendered on a patch with two triangles; and each mesh can contain multiple such patches, thus a group.
*/
-class BubbleActor : public RefObject
+class BubbleRenderer
{
public:
/**
- * Constructor
- * @param[in] numberOfBubble How many groups of uniforms are used to control the bubble movement.
- * Note: Limited by the maximum available uniforms, this parameter cannot be bigger than 100.
- * Ideally use one group of uniform to control one bubble.
- * If the num of patches in the MeshActor is more than groups of uniforms,
- * the uniform values will be shared by multiple bubbles. Allow up to 9 times.
- * @param[in] movementArea The size of the bubble moving area, usually the same size as the background.
+ * Constructor *
* @return A newly allocated object.
*/
- BubbleActor( unsigned int numberOfBubble,
- const Vector2& movementArea);
+ BubbleRenderer();
/**
* @brief Destructor
*/
- ~BubbleActor(){}
+ ~BubbleRenderer(){}
/**
- * Prepare for the rendering: create and add renderer, and register properties
+ * Prepare for the rendering: create the renderer, and register properties
+ * @param[in] numberOfBubble How many groups of uniforms are used to control the bubble movement.
+ * Note: Limited by the maximum available uniforms, this parameter cannot be bigger than 100.
+ * Ideally use one group of uniform to control one bubble.
+ * If the num of patches in the MeshActor is more than groups of uniforms,
+ * the uniform values will be shared by multiple bubbles. Allow up to 9 times.
+ * @param[in] movementArea The size of the bubble moving area, usually the same size as the background.
* @param[in] geometry The geometry to be used by the renderer
* @param[in] textureSet The texture set to be used by the renderer
- * @param[in] textureSet The shader set to be used by the renderer
+ * @param[in] shader The shader set to be used by the renderer
*/
- void MakeRenderable( Geometry geometry, TextureSet textureSet, Shader shader );
+ void Initialize( unsigned int numberOfBubble, const Vector2& movementArea, Geometry geometry, TextureSet textureSet, Shader shader );
/**
* Return the mesh actor which is used to display the bubbles
*/
- Actor GetMeshActor();
+ Renderer& GetRenderer();
/**
* Sets the geometry to be used by the renderer
void SetGeometry( Geometry geometry );
/**
- * Set the bubble movement area for the BubbleEffect
- * @param[in] movementArea The size of bubble movement area; by default, it is the stage size
- */
- void SetMovementArea( const Vector2& movementArea );
-
- /**
* Set the start and end positions of the index-th bubble's movement.
* @param[in] index Indicate which bubble these properties are applied on.
* @param[in] startAndEndPosition The start and the end position of movement.
private:
- Actor mActor;
Renderer mRenderer;
- Vector2 mMovementArea; ///< The size of the bubble moving area, usually the same size as the background.
-
//properties mapped as uniforms
std::vector<Property::Index> mIndicesOffset; ///< Indices of the properties mapping to uniform array 'uOffset'
std::vector<Property::Index> mIndiceStartEndPos; ///< Indices of the properties mapping to uniform array 'uStartAndEndPos'
Property::Index mIndexGravity; ///< Index of the property mapping to uniform 'uGravity'
Property::Index mIndexDynamicScale; ///< Index of the property mapping to uniform 'uDynamicScale'
Property::Index mIndexInvertedMovementArea; ///< Index of the property mapping to uniform 'uInvertedMovementArea'
-
- unsigned int mNumBubble; ///< How many groups of uniforms are used to control the bubble movement.
- unsigned int mRandomSeed; ///< Seed to generate random number.
};
} // namespace Internal
} // namespace Dali
-#endif // DALI_TOOLKIT_INTERNAL_BUBBLE_ACTOR_H
+#endif // DALI_TOOLKIT_INTERNAL_BUBBLE_RENDERER_H
$(toolkit_src_dir)/controls/alignment/alignment-impl.cpp \
$(toolkit_src_dir)/controls/bloom-view/bloom-view-impl.cpp \
$(toolkit_src_dir)/controls/bubble-effect/bubble-emitter-impl.cpp \
- $(toolkit_src_dir)/controls/bubble-effect/bubble-actor.cpp \
+ $(toolkit_src_dir)/controls/bubble-effect/bubble-renderer.cpp \
$(toolkit_src_dir)/controls/buttons/button-impl.cpp \
$(toolkit_src_dir)/controls/buttons/check-box-button-impl.cpp \
$(toolkit_src_dir)/controls/buttons/push-button-impl.cpp \