2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <cstdint> // uint32_t, uint16_t etc
23 #include <dali/public-api/rendering/frame-buffer.h>
24 #include <dali/public-api/rendering/renderer.h>
25 #include <dali/public-api/rendering/texture-set.h>
26 #include <dali/public-api/rendering/texture.h>
29 #include "shared/utility.h" // DemoHelper::LoadTexture
33 namespace // unnamed namespace for constants
35 const char* const BACKGROUND_IMAGE(DEMO_IMAGE_DIR "background-2.jpg");
36 const float GRAVITY_X(0);
37 const float GRAVITY_Y(-0.09);
39 // number of metaballs
40 constexpr uint32_t METABALL_NUMBER = 6;
45 * Vertex shader for metaballs
47 const char* const METABALL_VERTEX_SHADER = DALI_COMPOSE_SHADER (
48 attribute mediump vec2 aPosition;\n
49 attribute mediump vec2 aTexture;\n
50 uniform mediump mat4 uMvpMatrix;\n
51 uniform mediump vec3 uSize;\n
52 uniform lowp vec4 uColor;\n
53 varying mediump vec2 vTexCoord;\n
57 mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n
58 vertexPosition = uMvpMatrix * vertexPosition;\n
59 gl_Position = vertexPosition;\n
60 vTexCoord = aTexture;\n
65 * Fragment shader for metaballs
67 const char* const METABALL_FRAG_SHADER = DALI_COMPOSE_SHADER (
68 precision mediump float;\n
69 varying vec2 vTexCoord;\n
70 uniform vec2 uPositionMetaball;\n
71 uniform vec2 uPositionVar;\n
72 uniform vec2 uGravityVector;\n
73 uniform float uRadius;\n
74 uniform float uRadiusVar;\n
75 uniform float uAspect;\n
78 vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;\n
79 vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;\n
81 float distance = (adjustedCoords.x - finalMetaballPosition.x) * (adjustedCoords.x - finalMetaballPosition.x) +
82 (adjustedCoords.y - finalMetaballPosition.y) * (adjustedCoords.y - finalMetaballPosition.y);\n
83 float finalRadius = uRadius + uRadiusVar;\n
84 float color = finalRadius / sqrt( distance );\n
85 vec2 bordercolor = vec2(0.0,0.0);\n
86 if (vTexCoord.x < 0.1)\n
88 bordercolor.x = (0.1 - vTexCoord.x) * 0.8;\n
90 if (vTexCoord.x > 0.9)\n
92 bordercolor.x = (vTexCoord.x - 0.9) * 0.8;\n
94 if (vTexCoord.y < 0.1)\n
96 bordercolor.y = (0.1 - vTexCoord.y) * 0.8;\n
98 if (vTexCoord.y > (0.9 * uAspect))\n
100 bordercolor.y = (vTexCoord.y - (0.9 * uAspect)) * 0.8;\n
102 float border = (bordercolor.x + bordercolor.y) * 0.5;\n
103 gl_FragColor = vec4(color + border,color + border,color + border,1.0);\n
108 * Fragment shader code for metaball and background composition with refraction effect
110 const char* const REFRACTION_FRAG_SHADER = DALI_COMPOSE_SHADER (
111 precision mediump float;\n
112 varying vec2 vTexCoord;\n
113 uniform sampler2D sTexture;\n
114 uniform sampler2D sEffect;\n
117 vec4 metaColor = texture2D(sEffect, vTexCoord);\n
119 float bright = 1.0;\n
120 if (metaColor.r > 0.85)\n
122 zoomCoords = ((vTexCoord - 0.5) * 0.95) + 0.5;\n
124 else if (metaColor.r > 0.78)\n
126 float interpolation = mix(0.95, 1.05, (0.85 - metaColor.r) * 50.0);\n
127 zoomCoords = ((vTexCoord - 0.5) * interpolation) + 0.5;\n
132 zoomCoords = vTexCoord;\n
135 gl_FragColor = texture2D(sTexture, zoomCoords) * bright;\n
140 * Fragment shader code when there's no effect
142 const char* const FRAG_SHADER = DALI_COMPOSE_SHADER (
143 precision mediump float;\n
144 varying vec2 vTexCoord;\n
145 uniform sampler2D sTexture;\n
148 gl_FragColor = texture2D(sTexture, vTexCoord);\n
154 * Metadata for each ball
163 //Properties needed for animations
164 Property::Index positionIndex;
165 Property::Index positionVarIndex;
166 Property::Index gravityIndex;
167 Property::Index radiusIndex;
168 Property::Index radiusVarIndex;
169 Property::Index aspectIndex;
172 } // unnamed namespace
175 * Demo using Metaballs
177 * When the metaball is clicked it starts to grow and fuses into the closest edge of screen
179 class MetaballRefracController : public ConnectionTracker
186 MetaballRefracController(Application& application);
191 virtual ~MetaballRefracController();
194 * Creates the metaballs and initializes the scene
196 void Create(Application& app);
199 * Touch handler, start the grow animation and creates additional metaballs
201 bool OnTouch(Actor actor, const TouchEvent& touch);
204 * Key event callback to quit the application on escape or back key
206 void OnKeyEvent(const KeyEvent& event);
209 Application& mApplication;
212 Texture mBackgroundTexture;
213 FrameBuffer mMetaballFBO;
216 MetaballInfo mMetaballs[METABALL_NUMBER];
218 Actor mCompositionActor;
221 Vector2 mCurrentTouchPosition;
222 Vector2 mMetaballPosVariation;
223 Vector2 mMetaballPosVariationFrom;
224 Vector2 mMetaballPosVariationTo;
225 Vector2 mMetaballCenter;
230 Renderer mRendererRefraction;
231 TextureSet mTextureSetRefraction;
232 Shader mShaderRefraction;
233 TextureSet mTextureSetNormal;
234 Shader mShaderNormal;
237 Animation mGravityAnimation[METABALL_NUMBER];
238 Animation mRadiusDecAnimation[METABALL_NUMBER];
239 Animation mRadiusIncFastAnimation[METABALL_NUMBER];
240 Animation mRadiusIncSlowAnimation[METABALL_NUMBER];
241 Animation mRadiusVarAnimation[METABALL_NUMBER];
242 Animation mPositionVarAnimation[METABALL_NUMBER];
244 // Private Helper functions
247 * Create a mesh data with the geometry for the metaball rendering
248 * @param aspectMappedTexture whether texture coords should be mapped based on aspect ratio
250 Geometry CreateGeometry(bool aspectMappedTexture = true);
253 * Create a actor for the metaballs
255 void CreateMetaballActors();
258 * Create the render task and FBO to render the metaballs into a texture
260 void CreateMetaballImage();
263 * Create the the final composition
265 void CreateComposition();
268 * Create all the metaballs animations (gravity, movement, size, etc.)
270 void CreateAnimations();
273 * Function to launch the grow slow radius for the metaballs, and also the small variations for metaball[2] and [3]
275 void LaunchRadiusIncSlowAnimations(Animation& source);
278 * Function to launch the animation to get the metaball[1] back to the center
280 void LaunchGetBackToPositionAnimation(Animation& source);
283 * Function to stop all animations related to the click of the user in the screen
285 void StopClickAnimations();
288 * Function to stop all animations related to the after click of the user in the screen
290 void StopAfterClickAnimations();
293 * Function that resets the sate of the different Metaballs
295 void ResetMetaballsState();
298 * Function to set the actual position of the metaballs when the user clicks the screen
300 void SetPositionToMetaballs(const Vector2& metaballCenter);
307 MetaballRefracController::MetaballRefracController(Application& application)
308 : mApplication(application)
310 // Connect to the Application's Init signal
311 mApplication.InitSignal().Connect(this, &MetaballRefracController::Create);
314 MetaballRefracController::~MetaballRefracController()
316 // Nothing to do here;
319 void MetaballRefracController::Create(Application& app)
321 Window window = app.GetWindow();
323 window.KeyEventSignal().Connect(this, &MetaballRefracController::OnKeyEvent);
325 mScreenSize = window.GetSize();
327 window.SetBackgroundColor(Color::BLACK);
329 // Load background texture
330 mBackgroundTexture = DemoHelper::LoadTexture(BACKGROUND_IMAGE);
332 mGravity = Vector2(GRAVITY_X, GRAVITY_Y);
333 mGravityVar = Vector2(0, 0);
335 CreateMetaballActors();
336 CreateMetaballImage();
340 // Connect the callback to the touch signal on the mesh actor
341 window.GetRootLayer().TouchedSignal().Connect(this, &MetaballRefracController::OnTouch);
344 Geometry MetaballRefracController::CreateGeometry(bool aspectMappedTexture)
346 const float aspect = mScreenSize.y / mScreenSize.x;
348 // Create vertices and specify their color
349 const float xsize = mScreenSize.x * 0.5;
351 // Create the meshdata for the metaballs
352 struct VertexPosition
361 VertexPosition vertices[] =
363 {Vector2(-xsize, -xsize * aspect)},
364 {Vector2(xsize, -xsize * aspect)},
365 {Vector2(-xsize, xsize * aspect)},
366 {Vector2(xsize, xsize * aspect)}};
368 const float textureAspect = (aspectMappedTexture) ? aspect : 1.0f;
369 VertexTexture textures[] =
371 {Vector2(0.0f, 0.0f)},
372 {Vector2(1.0f, 0.0f)},
373 {Vector2(0.0f, 1.0f * textureAspect)},
374 {Vector2(1.0f, 1.0f * textureAspect)}};
376 uint32_t numberOfVertices = sizeof(vertices) / sizeof(VertexPosition);
379 Property::Map positionVertexFormat;
380 positionVertexFormat["aPosition"] = Property::VECTOR2;
381 VertexBuffer positionVertices = VertexBuffer::New(positionVertexFormat);
382 positionVertices.SetData(vertices, numberOfVertices);
385 Property::Map textureVertexFormat;
386 textureVertexFormat["aTexture"] = Property::VECTOR2;
387 VertexBuffer textureVertices = VertexBuffer::New(textureVertexFormat);
388 textureVertices.SetData(textures, numberOfVertices);
391 const uint16_t indices[] = {0, 3, 1, 0, 2, 3};
393 // Create the geometry object
394 Geometry texturedQuadGeometry = Geometry::New();
395 texturedQuadGeometry.AddVertexBuffer(positionVertices);
396 texturedQuadGeometry.AddVertexBuffer(textureVertices);
398 texturedQuadGeometry.SetIndexBuffer(&indices[0], sizeof(indices) / sizeof(indices[0]));
400 return texturedQuadGeometry;
403 void MetaballRefracController::CreateMetaballActors()
405 const float aspect = mScreenSize.y / mScreenSize.x;
407 // Create the renderer for the metaballs
408 Shader shader = Shader::New(METABALL_VERTEX_SHADER, METABALL_FRAG_SHADER, Shader::Hint::MODIFIES_GEOMETRY);
409 Geometry metaballGeometry = CreateGeometry();
410 Renderer renderer = Renderer::New(metaballGeometry, shader);
411 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
412 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE);
413 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE);
414 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE);
415 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE);
417 // Each metaball has a different radius
418 mMetaballs[0].radius = mMetaballs[0].initRadius = 0.0145f;
419 mMetaballs[1].radius = mMetaballs[1].initRadius = 0.012f;
420 mMetaballs[2].radius = mMetaballs[2].initRadius = 0.0135f;
421 mMetaballs[3].radius = mMetaballs[3].initRadius = 0.0135f;
423 // Initialization of each of the metaballs
424 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
426 mMetaballs[i].position = Vector2(0.0f, 0.0f);
428 mMetaballs[i].actor = Actor::New();
429 mMetaballs[i].actor.SetProperty(Dali::Actor::Property::NAME, "Metaball");
430 mMetaballs[i].actor.SetProperty(Actor::Property::SCALE, 1.0f);
431 mMetaballs[i].actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
433 mMetaballs[i].actor.AddRenderer(renderer);
435 mMetaballs[i].positionIndex = mMetaballs[i].actor.RegisterProperty("uPositionMetaball", mMetaballs[i].position);
436 mMetaballs[i].positionVarIndex = mMetaballs[i].actor.RegisterProperty("uPositionVar", Vector2(0.f, 0.f));
437 mMetaballs[i].gravityIndex = mMetaballs[i].actor.RegisterProperty("uGravityVector", Vector2(0.f, 0.f));
438 mMetaballs[i].radiusIndex = mMetaballs[i].actor.RegisterProperty("uRadius", mMetaballs[i].radius);
439 mMetaballs[i].radiusVarIndex = mMetaballs[i].actor.RegisterProperty("uRadiusVar", 0.f);
440 mMetaballs[i].aspectIndex = mMetaballs[i].actor.RegisterProperty("uAspect", aspect);
444 mMetaballRoot = Actor::New();
445 mMetaballRoot.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
446 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
448 mMetaballRoot.Add(mMetaballs[i].actor);
452 void MetaballRefracController::CreateMetaballImage()
454 // Create an FBO and a render task to create to render the metaballs with a fragment shader
455 Window window = mApplication.GetWindow();
456 mMetaballFBO = FrameBuffer::New(mScreenSize.x, mScreenSize.y);
458 window.Add(mMetaballRoot);
460 //Creation of the render task used to render the metaballs
461 RenderTaskList taskList = window.GetRenderTaskList();
462 RenderTask task = taskList.CreateTask();
463 task.SetRefreshRate(RenderTask::REFRESH_ALWAYS);
464 task.SetSourceActor(mMetaballRoot);
465 task.SetExclusive(true);
466 task.SetClearColor(Color::BLACK);
467 task.SetClearEnabled(true);
468 task.SetFrameBuffer(mMetaballFBO);
471 void MetaballRefracController::CreateComposition()
473 // Create Refraction shader and renderer
474 mShaderRefraction = Shader::New(METABALL_VERTEX_SHADER, REFRACTION_FRAG_SHADER);
476 // Create new texture set
477 mTextureSetRefraction = TextureSet::New();
478 mTextureSetRefraction.SetTexture(0u, mBackgroundTexture);
479 mTextureSetRefraction.SetTexture(1u, mMetaballFBO.GetColorTexture());
481 // Create normal shader
482 mShaderNormal = Shader::New(METABALL_VERTEX_SHADER, FRAG_SHADER);
484 // Create new texture set
485 mTextureSetNormal = TextureSet::New();
486 mTextureSetNormal.SetTexture(0u, mBackgroundTexture);
489 mCompositionActor = Actor::New();
490 mCompositionActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
491 mCompositionActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
492 mCompositionActor.SetProperty(Actor::Property::SIZE, Vector2(mScreenSize.x, mScreenSize.y));
495 Geometry metaballGeometry = CreateGeometry(false);
496 mRendererRefraction = Renderer::New(metaballGeometry, mShaderNormal);
497 mRendererRefraction.SetTextures(mTextureSetNormal);
498 mCompositionActor.AddRenderer(mRendererRefraction);
500 Window window = mApplication.GetWindow();
501 window.Add(mCompositionActor);
504 void MetaballRefracController::CreateAnimations()
509 mPositionVarAnimation[1] = Animation::New(2.f);
510 mPositionVarAnimation[1].SetLooping(false);
511 mPositionVarAnimation[1].Pause();
512 mPositionVarAnimation[1].FinishedSignal().Connect(this, &MetaballRefracController::LaunchGetBackToPositionAnimation);
514 KeyFrames keySinCosVariation = KeyFrames::New();
515 Vector2 sinCosVariation(0, 0);
516 for(i = 0; i < 360; i++)
518 sinCosVariation.x = 0.05f * (-sinf(i * Math::PI_OVER_180) + cosf(i * Math::PI_OVER_180));
519 sinCosVariation.y = 0.05f * (sinf(i * Math::PI_OVER_180) - cosf(i * Math::PI_OVER_180));
521 keySinCosVariation.Add(key, sinCosVariation);
524 mPositionVarAnimation[2] = Animation::New(6.f);
525 mPositionVarAnimation[2].AnimateBetween(Property(mMetaballs[2].actor, mMetaballs[2].positionVarIndex), keySinCosVariation);
526 mPositionVarAnimation[2].SetLooping(true);
527 mPositionVarAnimation[2].Pause();
529 KeyFrames keyCosSinVariation = KeyFrames::New();
530 Vector2 cosSinVariation(0, 0);
531 for(i = 0; i < 360; i++)
533 cosSinVariation.x = 0.05f * (-sinf(i * Math::PI_OVER_180) - cosf(i * Math::PI_OVER_180));
534 cosSinVariation.y = 0.05f * (sinf(i * Math::PI_OVER_180) + cosf(i * Math::PI_OVER_180));
536 keyCosSinVariation.Add(key, cosSinVariation);
539 mPositionVarAnimation[3] = Animation::New(6.f);
540 mPositionVarAnimation[3].AnimateBetween(Property(mMetaballs[3].actor, mMetaballs[3].positionVarIndex), keyCosSinVariation);
541 mPositionVarAnimation[3].SetLooping(true);
542 mPositionVarAnimation[3].Pause();
544 //Animations for gravity
545 for(i = 0; i < METABALL_NUMBER; i++)
547 mGravityAnimation[i] = Animation::New(25.f);
548 mGravityAnimation[i].AnimateBy(Property(mMetaballs[i].actor, mMetaballs[i].gravityIndex), mGravity * 25.f * 3.f);
549 mGravityAnimation[i].SetLooping(false);
550 mGravityAnimation[i].Pause();
553 //Animation to decrease size of metaballs when there is no click
554 for(i = 0; i < METABALL_NUMBER; i++)
556 mRadiusDecAnimation[i] = Animation::New(25.f);
557 mRadiusDecAnimation[i].AnimateBy(Property(mMetaballs[i].actor, mMetaballs[i].radiusIndex), -0.004f * 25.f * 3.f);
558 mRadiusDecAnimation[i].SetLooping(false);
559 mRadiusDecAnimation[i].Pause();
562 // Animation to grow the size of the metaballs the first second of the click
563 for(i = 0; i < METABALL_NUMBER; i++)
565 mRadiusIncFastAnimation[i] = Animation::New(0.3f);
566 mRadiusIncFastAnimation[i].AnimateBy(Property(mMetaballs[i].actor, mMetaballs[i].radiusIndex), 0.06f);
567 mRadiusIncFastAnimation[i].SetLooping(false);
568 mRadiusIncFastAnimation[i].Pause();
570 mRadiusIncFastAnimation[0].FinishedSignal().Connect(this, &MetaballRefracController::LaunchRadiusIncSlowAnimations);
572 // Animation to grow the size of the metaballs afterwards
573 for(i = 0; i < METABALL_NUMBER; i++)
575 mRadiusIncSlowAnimation[i] = Animation::New(20.f);
576 mRadiusIncSlowAnimation[i].AnimateBy(Property(mMetaballs[i].actor, mMetaballs[i].radiusIndex), 0.04f);
577 mRadiusIncSlowAnimation[i].SetLooping(false);
578 mRadiusIncSlowAnimation[i].Pause();
581 // Keyframes of a sin function
582 KeyFrames keySin = KeyFrames::New();
584 for(i = 0; i < 360; i++)
586 val = 0.01f * sin(i * Math::PI / 180.f);
588 keySin.Add(key, val);
591 //Animation to change the size of the metaball
592 mRadiusVarAnimation[2] = Animation::New(8.f);
593 mRadiusVarAnimation[2].AnimateBetween(Property(mMetaballs[2].actor, mMetaballs[2].radiusVarIndex), keySin);
594 mRadiusVarAnimation[2].SetLooping(true);
596 // Keyframes of a cos function
597 KeyFrames keyCos = KeyFrames::New();
598 for(i = 0; i < 360; i++)
600 val = 0.01f * cos(i * Math::PI / 180.f);
602 keyCos.Add(key, val);
605 //Animation to change the size of the metaball
606 mRadiusVarAnimation[3] = Animation::New(8.f);
607 mRadiusVarAnimation[3].AnimateBetween(Property(mMetaballs[3].actor, mMetaballs[3].radiusVarIndex), keyCos);
608 mRadiusVarAnimation[3].SetLooping(true);
611 void MetaballRefracController::LaunchGetBackToPositionAnimation(Animation& source)
613 mMetaballPosVariationTo = Vector2(0, 0);
615 mPositionVarAnimation[1] = Animation::New(1.f);
616 mPositionVarAnimation[1].SetLooping(false);
617 mPositionVarAnimation[1].AnimateTo(Property(mMetaballs[1].actor, mMetaballs[1].positionVarIndex), Vector2(0, 0));
618 mPositionVarAnimation[1].Play();
621 void MetaballRefracController::LaunchRadiusIncSlowAnimations(Animation& source)
623 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
625 mRadiusIncSlowAnimation[i].Play();
627 mPositionVarAnimation[2].Play();
628 mPositionVarAnimation[3].Play();
631 void MetaballRefracController::StopClickAnimations()
633 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
635 mRadiusIncSlowAnimation[i].Stop();
636 mRadiusIncFastAnimation[i].Stop();
638 mPositionVarAnimation[1].Stop();
639 mPositionVarAnimation[2].Stop();
640 mPositionVarAnimation[3].Stop();
643 void MetaballRefracController::StopAfterClickAnimations()
645 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
647 mGravityAnimation[i].Stop();
648 mRadiusDecAnimation[i].Stop();
650 mMetaballs[i].radius = mMetaballs[i].initRadius;
652 mMetaballs[i].actor.SetProperty(mMetaballs[i].gravityIndex, Vector2(0, 0));
653 mMetaballs[i].actor.SetProperty(mMetaballs[i].radiusIndex, mMetaballs[i].radius);
654 mMetaballs[i].actor.SetProperty(mMetaballs[i].radiusVarIndex, 0.f);
656 mRadiusVarAnimation[2].Stop();
657 mRadiusVarAnimation[3].Stop();
660 void MetaballRefracController::ResetMetaballsState()
662 mRendererRefraction.SetTextures(mTextureSetNormal);
663 mRendererRefraction.SetShader(mShaderNormal);
665 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
667 mMetaballs[i].radius = mMetaballs[i].initRadius;
670 mMetaballPosVariationTo = Vector2(0, 0);
671 mMetaballPosVariationFrom = Vector2(0, 0);
672 mMetaballPosVariation = Vector2(0, 0);
673 mGravityVar = Vector2(0, 0);
676 void MetaballRefracController::SetPositionToMetaballs(const Vector2& metaballCenter)
678 //We set the position for the metaballs based on click position
679 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
681 mMetaballs[i].position = metaballCenter;
682 mMetaballs[i].actor.SetProperty(mMetaballs[i].positionIndex, mMetaballs[i].position);
686 bool MetaballRefracController::OnTouch(Actor actor, const TouchEvent& touch)
688 const float aspect = mScreenSize.y / mScreenSize.x;
689 switch(touch.GetState(0))
691 case PointState::DOWN:
693 StopAfterClickAnimations();
694 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
696 mRadiusIncFastAnimation[i].Play();
698 mRadiusVarAnimation[2].Play();
699 mRadiusVarAnimation[3].Play();
701 //We draw with the refraction-composition shader
702 mRendererRefraction.SetTextures(mTextureSetRefraction);
703 mRendererRefraction.SetShader(mShaderRefraction);
704 mCurrentTouchPosition = touch.GetScreenPosition(0);
706 //we use the click position for the metaballs
707 Vector2 metaballCenter = Vector2((mCurrentTouchPosition.x / mScreenSize.x) - 0.5f,
708 (aspect * (mScreenSize.y - mCurrentTouchPosition.y) / mScreenSize.y) - 0.5f) *
710 SetPositionToMetaballs(metaballCenter);
713 case PointState::MOTION:
715 Vector2 screen = touch.GetScreenPosition(0);
716 Vector2 displacement = screen - mCurrentTouchPosition;
717 mCurrentTouchPosition = screen;
719 mMetaballPosVariationTo.x += (displacement.x / mScreenSize.x) * 2.2f;
720 mMetaballPosVariationTo.y += (-displacement.y / mScreenSize.y) * 2.2f;
722 if(mPositionVarAnimation[1])
724 mPositionVarAnimation[1].FinishedSignal().Disconnect(this, &MetaballRefracController::LaunchGetBackToPositionAnimation);
725 mPositionVarAnimation[1].Stop();
727 mPositionVarAnimation[1] = Animation::New(1.f);
728 mPositionVarAnimation[1].SetLooping(false);
729 mPositionVarAnimation[1].AnimateTo(Property(mMetaballs[1].actor, mMetaballs[1].positionVarIndex), mMetaballPosVariationTo);
730 mPositionVarAnimation[1].FinishedSignal().Connect(this, &MetaballRefracController::LaunchGetBackToPositionAnimation);
731 mPositionVarAnimation[1].Play();
733 //we use the click position for the metaballs
734 Vector2 metaballCenter = Vector2((screen.x / mScreenSize.x) - 0.5f,
735 (aspect * (mScreenSize.y - screen.y) / mScreenSize.y) - 0.5f) *
737 SetPositionToMetaballs(metaballCenter);
741 case PointState::LEAVE:
742 case PointState::INTERRUPTED:
744 //Stop click animations
745 StopClickAnimations();
747 //Launch out of screen animations
748 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
750 mGravityAnimation[i].Play();
753 for(uint32_t i = 0; i < METABALL_NUMBER; i++)
755 mRadiusDecAnimation[i].Play();
765 void MetaballRefracController::OnKeyEvent(const KeyEvent& event)
767 if(event.GetState() == KeyEvent::DOWN)
769 if(IsKey(event, Dali::DALI_KEY_ESCAPE) || IsKey(event, Dali::DALI_KEY_BACK))
779 int32_t DALI_EXPORT_API main(int argc, char** argv)
781 Application application = Application::New(&argc, &argv);
783 MetaballRefracController test(application);
784 application.MainLoop();