/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
// 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/public-api/rendering/shader.h>
+#include <dali/public-api/rendering/texture.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>
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
namespace
{
struct Vertex
{
Vertex()
- : index( 0.0f ), position(), textureCoord()
+ : index(0.0f),
+ position(),
+ textureCoord()
{
}
- Vertex( float index, const Dali::Vector2& position, const Dali::Vector2& textureCoord )
- : index( index ), position( position ), textureCoord( textureCoord )
+ Vertex(float index, const Dali::Vector2& position, const Dali::Vector2& textureCoord)
+ : index(index),
+ position(position),
+ textureCoord(textureCoord)
{
}
- float index;
+ float index;
Dali::Vector2 position;
Dali::Vector2 textureCoord;
};
*/
float RandomRange(float f0, float f1, unsigned int& seed)
{
- return f0 + (rand_r( &seed ) & 0xfff) * (f1-f0) * (1.0f/4095.0f);
+ return f0 + (rand_r(&seed) & 0xfff) * (f1 - f0) * (1.0f / 4095.0f);
}
+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::VertexBuffer vertexBuffer = Dali::VertexBuffer::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
+
namespace Dali
{
-
namespace Toolkit
{
-
namespace Internal
{
-BubbleEmitter::BubbleEmitter( const Vector2& movementArea,
- Image shapeImage,
- unsigned int maximumNumberOfBubble,
- const Vector2& bubbleSizeRange )
-: Control( ControlBehaviour( REQUIRES_TOUCH_EVENTS ) ),
- mShapeImage( shapeImage ),
- mMovementArea( movementArea ),
- mBubbleSizeRange( bubbleSizeRange ),
- mDensity( 5 ),
- mTotalNumOfBubble( maximumNumberOfBubble ),
- mCurrentBubble( 0 ),
- mRandomSeed( 0 ),
+BubbleEmitter::BubbleEmitter(const Vector2& movementArea,
+ Texture shapeTexture,
+ unsigned int maximumNumberOfBubble,
+ const Vector2& bubbleSizeRange)
+: Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
+ mShapeTexture(shapeTexture),
+ mMovementArea(movementArea),
+ mBubbleSizeRange(bubbleSizeRange),
+ mDensity(5),
+ mTotalNumOfBubble(maximumNumberOfBubble),
+ mCurrentBubble(0),
+ mRandomSeed(0),
mRenderTaskRunning(false)
{
// Calculate how many shaders are required
- if( mTotalNumOfBubble>100 )
+ 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 );
+ mRandomSeed = time(NULL);
}
BubbleEmitter::~BubbleEmitter()
{
}
-Toolkit::BubbleEmitter BubbleEmitter::New( const Vector2& winSize,
- Image shapeImage,
- unsigned int maximumNumberOfBubble,
- const Vector2& bubbleSizeRange )
+Toolkit::BubbleEmitter BubbleEmitter::New(const Vector2& winSize,
+ Texture shapeTexture,
+ unsigned int maximumNumberOfBubble,
+ const Vector2& bubbleSizeRange)
{
// Create the implementation
- IntrusivePtr<BubbleEmitter> internalBubbleEmitter ( new BubbleEmitter( winSize, shapeImage,
- maximumNumberOfBubble,bubbleSizeRange ) );
+ IntrusivePtr<BubbleEmitter> internalBubbleEmitter(new BubbleEmitter(winSize, shapeTexture, maximumNumberOfBubble, bubbleSizeRange));
// Pass ownership to Toolkit::BubbleEmitter handle
- Toolkit::BubbleEmitter bubbleEmitter( *internalBubbleEmitter );
+ Toolkit::BubbleEmitter bubbleEmitter(*internalBubbleEmitter);
//Second phase of implementeation : Initialization
internalBubbleEmitter->OnInitialize();
{
// Create the root actor, all the meshActor should be its children
mBubbleRoot = Actor::New();
- mBubbleRoot.SetSize(mMovementArea);
+ mBubbleRoot.SetProperty(Actor::Property::SIZE, 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, Dali::Image::UNUSED );
+ // 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, FrameBuffer::Attachment::NONE);
+ 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();
- mTextureSet.SetImage( 0u, mEffectImage );
- mTextureSet.SetImage( 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.
mCameraActor = CameraActor::New(mMovementArea);
- mCameraActor.SetParentOrigin(ParentOrigin::CENTER);
+ mCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
Stage stage = Stage::GetCurrent();
return mBubbleRoot;
}
-void BubbleEmitter::SetBackground( Image bgImage, const Vector3& hsvDelta )
+void BubbleEmitter::SetBackground(Texture bgTexture, const Vector3& hsvDelta)
{
- mBackgroundImage = bgImage;
- mHSVDelta = hsvDelta;
-
- Toolkit::ImageView sourceActor = Toolkit::ImageView::New( bgImage );
- 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*/ );
-
- Stage::GetCurrent().Add( sourceActor );
+ mBackgroundTexture = bgTexture;
+ mHSVDelta = hsvDelta;
+
+ //Create RenderTask source actor
+ Actor sourceActor = Actor::New();
+ sourceActor.SetProperty(Actor::Property::SIZE, mMovementArea);
+ sourceActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ sourceActor.RegisterProperty("uHSVDelta", hsvDelta);
+ Stage::GetCurrent().Add(sourceActor);
+
+ //Create renderer
+ Dali::Geometry geometry = CreateTexturedQuad();
+ Shader shader = Shader::New(SHADER_BUBBLE_EMITTER_VERT, SHADER_BUBBLE_EMITTER_FRAG);
+ 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.SetSourceActor( sourceActor );
+ RenderTask task = taskList.CreateTask();
+ task.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ task.SetSourceActor(sourceActor);
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)
{
- mTextureSet.SetImage( 1, shapeImage );
+ mTextureSet.SetTexture(1, shapeTexture);
}
-void BubbleEmitter::SetBubbleScale( float scale )
+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);
}
}
-void BubbleEmitter::SetBubbleDensity( unsigned int density )
+void BubbleEmitter::SetBubbleDensity(unsigned int density)
{
- DALI_ASSERT_ALWAYS( density>0 && density<=9 && " Only densities between 1 to 9 are valid " );
+ DALI_ASSERT_ALWAYS(density > 0 && density <= 9 && " Only densities between 1 to 9 are valid ");
- if( density == mDensity )
+ if(density == mDensity)
{
return;
}
else
{
- mDensity = density;
- mMeshGeometry = CreateGeometry( mNumBubblePerActor*mDensity );
- for(unsigned int i=0; i < mNumActor; i++ )
+ mDensity = density;
+ mMeshGeometry = CreateGeometry(mNumBubblePerRenderer * mDensity);
+ for(unsigned int i = 0; i < mNumRenderer; i++)
{
- (mBubbleActors[i])->SetGeometry( mMeshGeometry );
+ mBubbleRenderers[i].SetGeometry(mMeshGeometry);
}
}
}
void BubbleEmitter::OnRenderFinished(RenderTask& source)
{
mRenderTaskRunning = false;
- Actor sourceActor = source.GetSourceActor();
- Stage stage = Stage::GetCurrent();
+ Actor sourceActor = source.GetSourceActor();
+ Stage stage = Stage::GetCurrent();
stage.Remove(sourceActor);
stage.GetRenderTaskList().RemoveTask(source);
}
{
// Context was lost, so the framebuffer has been destroyed. Re-create render task
// and trigger re-draw if not already running
- if( ! mRenderTaskRunning )
+ if(!mRenderTaskRunning)
{
- SetBackground( mBackgroundImage, mHSVDelta );
+ SetBackground(mBackgroundTexture, mHSVDelta);
}
}
-void BubbleEmitter::EmitBubble( Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement )
+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),
- 1.f, AlphaFunction::LINEAR );
+ 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 )
+Geometry BubbleEmitter::CreateGeometry(unsigned int numOfPatch)
{
- unsigned int numVertex = numOfPatch*4u;
- std::vector<Vertex> vertexData;
- vertexData.reserve( numVertex );
+ unsigned int numVertex = numOfPatch * 4u;
+ Vector<Vertex> vertexData;
+ vertexData.Reserve(numVertex);
- unsigned int numIndex = numOfPatch*6u;
+ unsigned int numIndex = numOfPatch * 6u;
Vector<unsigned short> indexData;
- indexData.Reserve( numIndex );
+ indexData.Reserve(numIndex);
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) ) );
+ float index = static_cast<float>(i);
+ 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 );
- indexData.PushBack( idx+1 );
- indexData.PushBack( idx+2 );
- indexData.PushBack( idx );
- indexData.PushBack( idx+2 );
- indexData.PushBack( idx+3 );
+ indexData.PushBack(idx);
+ indexData.PushBack(idx + 1);
+ indexData.PushBack(idx + 2);
+ indexData.PushBack(idx);
+ indexData.PushBack(idx + 2);
+ indexData.PushBack(idx + 3);
}
Property::Map vertexFormat;
- vertexFormat["aIndex"] = Property::FLOAT;
+ vertexFormat["aIndex"] = Property::FLOAT;
vertexFormat["aPosition"] = Property::VECTOR2;
vertexFormat["aTexCoord"] = Property::VECTOR2;
- PropertyBuffer vertices = PropertyBuffer::New( vertexFormat );
- vertices.SetData( &vertexData[0], numVertex );
+ VertexBuffer vertices = VertexBuffer::New(vertexFormat);
+ vertices.SetData(&vertexData[0], numVertex);
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertices );
- geometry.SetIndexBuffer( &indexData[0], numIndex );
+ geometry.AddVertexBuffer(vertices);
+ geometry.SetIndexBuffer(&indexData[0], numIndex);
return geometry;
}
-void BubbleEmitter::SetBubbleParameter( BubbleActorPtr bubbleActor, unsigned int curUniform,
- const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement )
+void BubbleEmitter::SetBubbleParameter(BubbleRenderer& bubbleRenderer, unsigned int curUniform, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement)
{
Vector2 dir(direction);
int halfRange = displacement.x / 2;
// for the y coordinate, always negative, so bubbles always go upwards
- Vector2 randomVec( rand_r( &mRandomSeed ) % static_cast<int>(displacement.x) - halfRange, -rand_r( &mRandomSeed ) % static_cast<int>(displacement.y) );
+ Vector2 randomVec(rand_r(&mRandomSeed) % static_cast<int>(displacement.x) - halfRange, -rand_r(&mRandomSeed) % static_cast<int>(displacement.y));
dir.Normalize();
- randomVec.x -= dir.x*halfRange;
- randomVec.y *= 1.0f - fabsf(dir.x)*0.33f;
+ randomVec.x -= dir.x * halfRange;
+ randomVec.y *= 1.0f - fabsf(dir.x) * 0.33f;
if(randomVec.y > 0.0f)
{
randomVec.y *= 0.33f;
}
- Vector4 startAndEndPos( emitPosition.x, emitPosition.y, emitPosition.x+randomVec.x, emitPosition.y+randomVec.y );
- bubbleActor->SetStartAndEndPosition( curUniform, startAndEndPos );
+ Vector4 startAndEndPos(emitPosition.x, emitPosition.y, emitPosition.x + randomVec.x, emitPosition.y + randomVec.y);
+ bubbleRenderer.SetStartAndEndPosition(curUniform, startAndEndPos);
- bubbleActor->SetPercentage( curUniform, 0.f);
+ bubbleRenderer.SetPercentage(curUniform, 0.f);
}
} // namespace Internal