2 * Copyright (c) 2014 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.
18 #include <dali/dali.h>
19 #include <dali/devel-api/rendering/renderer.h>
20 #include <dali-toolkit/dali-toolkit.h>
26 using namespace Dali::Toolkit;
30 const char * const BACKGROUND_IMAGE( DEMO_IMAGE_DIR "background-2.jpg" );
31 const char * const TOOLBAR_IMAGE( DEMO_IMAGE_DIR "top-bar.png" );
33 const float GRAVITY_X(0);
34 const float GRAVITY_Y(-0.09);
37 #define METABALL_NUMBER 4
39 const char*const METABALL_VERTEX_SHADER = DALI_COMPOSE_SHADER (
40 attribute mediump vec2 aPosition;\n
41 attribute mediump vec2 aTexture;\n
42 attribute mediump vec3 aNormal;\n
43 uniform mediump mat4 uMvpMatrix;\n
44 uniform mediump vec3 uSize;\n
45 uniform lowp vec4 uColor;\n
46 varying mediump vec2 vTexCoord;\n
50 mediump vec4 vertexPosition = vec4(aPosition.x, aPosition.y, 0.0, 1.0);\n
51 vertexPosition = uMvpMatrix * vertexPosition;\n
52 gl_Position = vertexPosition;\n
53 vTexCoord = aTexture;\n
58 const char*const METABALL_FRAG_SHADER = DALI_COMPOSE_SHADER (
59 precision mediump float;\n
60 varying vec2 vTexCoord;\n
61 uniform vec2 uPositionMetaball;\n
62 uniform vec2 uPositionVar;\n
63 uniform vec2 uGravityVector;\n
64 uniform float uRadius;\n
65 uniform float uRadiusVar;\n
66 uniform float uAspect;\n
69 vec2 adjustedCoords = vTexCoord * 2.0 - 1.0;\n
70 vec2 finalMetaballPosition = uPositionMetaball + uGravityVector + uPositionVar;\n
72 float distance = (adjustedCoords.x - finalMetaballPosition.x) * (adjustedCoords.x - finalMetaballPosition.x) +
73 (adjustedCoords.y - finalMetaballPosition.y) * (adjustedCoords.y - finalMetaballPosition.y);\n
74 float finalRadius = uRadius + uRadiusVar;\n
75 float color = finalRadius / sqrt( distance );\n
76 vec2 bordercolor = vec2(0.0,0.0);\n
77 if (vTexCoord.x < 0.1)\n
79 bordercolor.x = (0.1 - vTexCoord.x) * 0.8;\n
81 if (vTexCoord.x > 0.9)\n
83 bordercolor.x = (vTexCoord.x - 0.9) * 0.8;\n
85 if (vTexCoord.y < 0.1)\n
87 bordercolor.y = (0.1 - vTexCoord.y) * 0.8;\n
89 if (vTexCoord.y > (0.9 * uAspect))\n
91 bordercolor.y = (vTexCoord.y - (0.9 * uAspect)) * 0.8;\n
93 float border = (bordercolor.x + bordercolor.y) * 0.5;\n
94 gl_FragColor = vec4(color + border,color + border,color + border,1.0);\n
98 const char*const REFRACTION_FRAG_SHADER = DALI_COMPOSE_SHADER (
99 precision mediump float;\n
100 varying vec2 vTexCoord;\n
101 uniform sampler2D sTexture;\n
102 uniform sampler2D sEffect;\n
105 vec4 metaColor = texture2D(sEffect, vTexCoord);\n
107 float bright = 1.0;\n
108 if (metaColor.r > 0.85)\n
110 zoomCoords = ((vTexCoord - 0.5) * 0.95) + 0.5;\n
112 else if (metaColor.r > 0.81)\n
114 float interpolation = mix(0.95, 1.05, (0.85 - metaColor.r) * 50.0);\n
115 zoomCoords = ((vTexCoord - 0.5) * interpolation) + 0.5;\n
120 zoomCoords = vTexCoord;\n
123 gl_FragColor = texture2D(sTexture, zoomCoords) * bright;\n
127 const char*const FRAG_SHADER = DALI_COMPOSE_SHADER (
128 precision mediump float;\n
129 varying vec2 vTexCoord;\n
130 uniform sampler2D sTexture;\n
133 gl_FragColor = texture2D(sTexture, vTexCoord);\n
140 //ShaderEffect shader;
146 //Properties needed for animations
147 Property::Index positionIndex;
148 Property::Index positionVarIndex;
149 Property::Index gravityIndex;
150 Property::Index radiusIndex;
151 Property::Index radiusVarIndex;
152 Property::Index aspectIndex;
156 /***************************************************************************/
157 /* Demo using Metaballs for Refraction when clicking the screen ************/
158 /* The concept is similar to the Note 5 ScreenLock ************/
159 /***************************************************************************/
160 class MetaballRefracController : public ConnectionTracker
163 MetaballRefracController( Application& application );
164 ~MetaballRefracController();
166 void Create( Application& app );
167 bool OnTouch( Actor actor, const TouchEvent& touch );
168 void OnKeyEvent(const KeyEvent& event);
170 void SetGravity(const Vector2 & gravity);
174 Application& mApplication;
180 FrameBufferImage mMetaballFBO;
183 MetaballInfo mMetaballs[METABALL_NUMBER];
185 Actor mCompositionActor;
189 Vector2 mCurrentTouchPosition;
190 Vector2 mMetaballPosVariation;
191 Vector2 mMetaballPosVariationFrom;
192 Vector2 mMetaballPosVariationTo;
193 Vector2 mMetaballCenter;
198 Renderer mRendererRefraction;
199 Material mMaterialRefraction;
200 Material mMaterialNormal;
203 Animation mGravityAnimation[METABALL_NUMBER];
204 Animation mRadiusDecAnimation[METABALL_NUMBER];
205 Animation mRadiusIncFastAnimation[METABALL_NUMBER];
206 Animation mRadiusIncSlowAnimation[METABALL_NUMBER];
207 Animation mRadiusVarAnimation[METABALL_NUMBER];
208 Animation mPositionVarAnimation[METABALL_NUMBER];
211 Geometry CreateGeometry();
212 Geometry CreateGeometryComposition();
214 void CreateMetaballActors();
215 void CreateMetaballImage();
216 void AddRefractionImage();
217 void CreateAnimations();
219 void LaunchRadiusIncSlowAnimations(Animation &source);
220 void LaunchGetBackToPositionAnimation(Animation &source);
222 void StopClickAnimations();
223 void StopAfterClickAnimations();
225 void ResetMetaballsState();
227 void SetPositionToMetaballs(Vector2 & metaballCenter);
231 //-----------------------------------------------------------------------------------------------
237 MetaballRefracController::MetaballRefracController( Application& application )
238 : mApplication( application )
240 // Connect to the Application's Init signal
241 mApplication.InitSignal().Connect( this, &MetaballRefracController::Create );
244 MetaballRefracController::~MetaballRefracController()
246 // Nothing to do here;
250 * Setter function for gravity
252 void MetaballRefracController::SetGravity(const Vector2 & gravity)
258 * Main create function, it creates the metaballs and all the
260 void MetaballRefracController::Create( Application& app )
262 Stage stage = Stage::GetCurrent();
264 stage.KeyEventSignal().Connect(this, &MetaballRefracController::OnKeyEvent);
266 mScreenSize = stage.GetSize();
268 stage.SetBackgroundColor(Color::BLACK);
270 //Set background image for the view
271 mBackImage = ResourceImage::New( BACKGROUND_IMAGE );
273 mGravity = Vector2(GRAVITY_X,GRAVITY_Y);
274 mGravityVar = Vector2(0,0);
276 //Create internal data
277 CreateMetaballActors();
278 CreateMetaballImage();
279 AddRefractionImage();
283 // Connect the callback to the touch signal on the mesh actor
284 stage.GetRootLayer().TouchedSignal().Connect( this, &MetaballRefracController::OnTouch );
288 * Create a mesh data with the geometry for the metaball rendering
290 Geometry MetaballRefracController::CreateGeometry()
292 float aspect = (float)mScreenSize.y / (float)mScreenSize.x;
294 // Create vertices and specify their color
295 float xsize = mScreenSize.x * 0.5;
297 //We create the meshdata for the metaballs
298 struct VertexPosition { Vector2 position; };
299 struct VertexTexture { Vector2 texture; };
300 struct VertexNormal { Vector3 normal; };
302 VertexPosition vertices[] = {
303 { Vector2( -xsize, -xsize * aspect) },
304 { Vector2( xsize, -xsize * aspect) },
305 { Vector2( -xsize, xsize * aspect) },
306 { Vector2( xsize, xsize * aspect) }
309 VertexTexture textures[] = {
310 { Vector2(0.0f, 0.0f) },
311 { Vector2(1.0f, 0.0f) },
312 { Vector2(0.0f, 1.0f * aspect) },
313 { Vector2(1.0f, 1.0f * aspect) }
316 VertexNormal normals [] = {
317 { Vector3(0.0f, 0.0f, 1.0f) },
318 { Vector3(0.0f, 0.0f, 1.0f) },
319 { Vector3(0.0f, 0.0f, 1.0f) },
320 { Vector3(0.0f, 0.0f, 1.0f) }
323 int indices[] = { 0, 3, 1, 0, 2, 3 };
325 unsigned int numberOfVertices = sizeof(vertices)/sizeof(VertexPosition);
328 Property::Map positionVertexFormat;
329 positionVertexFormat["aPosition"] = Property::VECTOR2;
330 PropertyBuffer positionVertices = PropertyBuffer::New( positionVertexFormat );
331 positionVertices.SetData( vertices, numberOfVertices );
334 Property::Map textureVertexFormat;
335 textureVertexFormat["aTexture"] = Property::VECTOR2;
336 PropertyBuffer textureVertices = PropertyBuffer::New( textureVertexFormat );
337 textureVertices.SetData( textures, numberOfVertices );
340 Property::Map normalVertexFormat;
341 normalVertexFormat["aNormal"] = Property::VECTOR3;
342 PropertyBuffer normalVertices = PropertyBuffer::New( normalVertexFormat );
343 normalVertices.SetData( normals, numberOfVertices );
346 Property::Map indicesVertexFormat;
347 indicesVertexFormat["aIndices"] = Property::INTEGER;
348 PropertyBuffer indicesToVertices = PropertyBuffer::New( indicesVertexFormat );
349 indicesToVertices.SetData( indices, 6 );
352 // Create the geometry object
353 Geometry texturedQuadGeometry = Geometry::New();
354 texturedQuadGeometry.AddVertexBuffer( positionVertices );
355 texturedQuadGeometry.AddVertexBuffer( textureVertices );
356 texturedQuadGeometry.AddVertexBuffer( normalVertices );
358 texturedQuadGeometry.SetIndexBuffer ( indicesToVertices );
360 return texturedQuadGeometry;
364 * Create a mesh data with the geometry for the metaball rendering
366 Geometry MetaballRefracController::CreateGeometryComposition()
368 float aspect = (float)mScreenSize.y / (float)mScreenSize.x;
370 // Create vertices and specify their color
371 float xsize = mScreenSize.x * 0.5;
373 //We create the meshdata for the metaballs
374 struct VertexPosition { Vector2 position; };
375 struct VertexTexture { Vector2 texture; };
376 struct VertexNormal { Vector3 normal; };
378 VertexPosition vertices[] = {
379 { Vector2( -xsize, -xsize * aspect) },
380 { Vector2( xsize, -xsize * aspect) },
381 { Vector2( -xsize, xsize * aspect) },
382 { Vector2( xsize, xsize * aspect) }
385 VertexTexture textures[] = {
386 { Vector2(0.0f, 0.0f) },
387 { Vector2(1.0f, 0.0f) },
388 { Vector2(0.0f, 1.0f) },
389 { Vector2(1.0f, 1.0f) }
392 VertexNormal normals [] = {
393 { Vector3(0.0f, 0.0f, 1.0f) },
394 { Vector3(0.0f, 0.0f, 1.0f) },
395 { Vector3(0.0f, 0.0f, 1.0f) },
396 { Vector3(0.0f, 0.0f, 1.0f) }
399 int indices[] = { 0, 3, 1, 0, 2, 3 };
401 unsigned int numberOfVertices = sizeof(vertices)/sizeof(VertexPosition);
404 Property::Map positionVertexFormat;
405 positionVertexFormat["aPosition"] = Property::VECTOR2;
406 PropertyBuffer positionVertices = PropertyBuffer::New( positionVertexFormat );
407 positionVertices.SetData( vertices, numberOfVertices );
410 Property::Map textureVertexFormat;
411 textureVertexFormat["aTexture"] = Property::VECTOR2;
412 PropertyBuffer textureVertices = PropertyBuffer::New( textureVertexFormat );
413 textureVertices.SetData( textures, numberOfVertices );
416 Property::Map normalVertexFormat;
417 normalVertexFormat["aNormal"] = Property::VECTOR3;
418 PropertyBuffer normalVertices = PropertyBuffer::New( normalVertexFormat );
419 normalVertices.SetData( normals, numberOfVertices );
422 Property::Map indicesVertexFormat;
423 indicesVertexFormat["aIndices"] = Property::INTEGER;
424 PropertyBuffer indicesToVertices = PropertyBuffer::New( indicesVertexFormat );
425 indicesToVertices.SetData( indices, 6 );
427 // Create the geometry object
428 Geometry texturedQuadGeometry = Geometry::New();
429 texturedQuadGeometry.AddVertexBuffer( positionVertices );
430 texturedQuadGeometry.AddVertexBuffer( textureVertices );
431 texturedQuadGeometry.AddVertexBuffer( normalVertices );
433 texturedQuadGeometry.SetIndexBuffer ( indicesToVertices );
435 return texturedQuadGeometry;
439 * Create a mesh actor for the metaballs
441 void MetaballRefracController::CreateMetaballActors()
443 //We create metaball structures
444 //With MeshData Textured
445 float aspect = (float)mScreenSize.y / (float)mScreenSize.x;
447 //Create the shader for the metaballs
449 Shader shader = Shader::New( METABALL_VERTEX_SHADER, METABALL_FRAG_SHADER );
451 Material material = Material::New( shader );
453 Geometry metaballGeom = CreateGeometry();
455 //Each metaball has a different radius
456 mMetaballs[0].radius = mMetaballs[0].initRadius = 0.0145f;
457 mMetaballs[1].radius = mMetaballs[1].initRadius = 0.012f;
458 mMetaballs[2].radius = mMetaballs[2].initRadius = 0.0135f;
459 mMetaballs[3].radius = mMetaballs[3].initRadius = 0.0135f;
461 //Initialization of each of the metaballs
462 for (int i = 0 ; i < METABALL_NUMBER ; i++)
464 mMetaballs[i].position = Vector2(0.0f, 0.0f);
466 mMetaballs[i].actor = Actor::New( );
467 mMetaballs[i].actor.SetName("Metaball");
468 mMetaballs[i].actor.SetScale( 1.0f );
469 mMetaballs[i].actor.SetParentOrigin( ParentOrigin::CENTER );
471 Renderer renderer = Renderer::New( metaballGeom, material );
472 renderer.SetProperty( Renderer::Property::BLENDING_MODE, BlendingMode::ON );
473 renderer.SetBlendFunc(BlendingFactor::ONE, BlendingFactor::ONE, BlendingFactor::ONE, BlendingFactor::ONE);
474 mMetaballs[i].actor.AddRenderer( renderer );
476 mMetaballs[i].positionIndex = mMetaballs[i].actor.RegisterProperty( "uPositionMetaball", mMetaballs[i].position );
478 mMetaballs[i].positionVarIndex = mMetaballs[i].actor.RegisterProperty( "uPositionVar", Vector2(0.f,0.f) );
480 mMetaballs[i].gravityIndex = mMetaballs[i].actor.RegisterProperty( "uGravityVector", Vector2(0.f,0.f) );
482 mMetaballs[i].radiusIndex = mMetaballs[i].actor.RegisterProperty( "uRadius", mMetaballs[i].radius );
484 mMetaballs[i].radiusVarIndex = mMetaballs[i].actor.RegisterProperty( "uRadiusVar", 0.f );
486 mMetaballs[i].aspectIndex = mMetaballs[i].actor.RegisterProperty( "uAspect", aspect );
488 mMetaballs[i].actor.SetSize(400, 400);
492 mMetaballRoot = Actor::New();
493 mMetaballRoot.SetParentOrigin( ParentOrigin::CENTER );
494 for (int i = 0 ; i < METABALL_NUMBER ; i++)
496 mMetaballRoot.Add( mMetaballs[i].actor );
499 //Initialization of variables related to metaballs
500 mMetaballPosVariation = Vector2(0,0);
501 mMetaballPosVariationFrom = Vector2(0,0);
502 mMetaballPosVariationTo = Vector2(0,0);
503 mCurrentTouchPosition = Vector2(0,0);
507 * Create the render task and FBO to render the metaballs into a texture
509 void MetaballRefracController::CreateMetaballImage()
511 //We create an FBO and a render task to create to render the metaballs with a fragment shader
512 Stage stage = Stage::GetCurrent();
513 mMetaballFBO = FrameBufferImage::New(mScreenSize.x, mScreenSize.y );
515 stage.Add(mMetaballRoot);
517 //Creation of the render task used to render the metaballs
518 RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
519 RenderTask task = taskList.CreateTask();
520 task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
521 task.SetSourceActor( mMetaballRoot );
522 task.SetExclusive(true);
523 task.SetClearColor( Color::BLACK );
524 task.SetClearEnabled( true );
525 task.SetTargetFrameBuffer( mMetaballFBO );
529 * Create a mesh image to render the final composition
531 void MetaballRefracController::AddRefractionImage()
533 //Creation of the composition image
536 Geometry metaballGeom = CreateGeometryComposition();
538 //Create Refraction shader and renderer
539 Shader shader = Shader::New( METABALL_VERTEX_SHADER, REFRACTION_FRAG_SHADER );
540 //Create new material
541 mMaterialRefraction = Material::New( shader );
544 mMaterialRefraction.AddTexture(mBackImage, "sTexture");
545 mMaterialRefraction.AddTexture(mMetaballFBO, "sEffect");
547 //Create normal shader
548 Shader shaderNormal = Shader::New( METABALL_VERTEX_SHADER, FRAG_SHADER );
549 //Create new material
550 mMaterialNormal = Material::New( shaderNormal );
553 mMaterialNormal.AddTexture(mBackImage, "sTexture");
557 mCompositionActor = Actor::New( );
558 mCompositionActor.SetParentOrigin(ParentOrigin::CENTER);
559 mCompositionActor.SetPosition(Vector3(0.0f, 0.0f, 0.0f));
560 mCompositionActor.SetSize(mScreenSize.x, mScreenSize.y);
563 mRendererRefraction = Renderer::New( metaballGeom, mMaterialNormal );
564 mCompositionActor.AddRenderer( mRendererRefraction );
566 Stage stage = Stage::GetCurrent();
567 stage.Add( mCompositionActor );
571 * Creation of all the metaballs animations (gravity, movement, size, etc.)
573 void MetaballRefracController::CreateAnimations()
578 mPositionVarAnimation[1] = Animation::New(2.f);
579 mPositionVarAnimation[1].SetLooping( false );
580 mPositionVarAnimation[1].Pause();
581 mPositionVarAnimation[1].FinishedSignal().Connect( this, &MetaballRefracController::LaunchGetBackToPositionAnimation );
583 KeyFrames keySinCosVariation = KeyFrames::New();
584 Vector2 sinCosVariation(0,0);
585 for ( i = 0 ; i < 360 ; i++)
587 sinCosVariation.x = 0.05f * (-sin(i * Math::PI/180.f) + cos(i * Math::PI/180.f));
588 sinCosVariation.y = 0.05f * (sin(i * Math::PI/180.f) - cos(i * Math::PI/180.f));
590 keySinCosVariation.Add(key, sinCosVariation);
593 mPositionVarAnimation[2] = Animation::New(6.f);
594 mPositionVarAnimation[2].AnimateBetween(Property( mMetaballs[2].actor, mMetaballs[2].positionVarIndex ), keySinCosVariation);
595 mPositionVarAnimation[2].SetLooping( true );
596 mPositionVarAnimation[2].Pause();
598 KeyFrames keyCosSinVariation = KeyFrames::New();
599 Vector2 cosSinVariation(0,0);
600 for ( i = 0 ; i < 360 ; i++)
602 cosSinVariation.x = 0.05f * (-sin(i * Math::PI/180.f) - cos(i * Math::PI/180.f));
603 cosSinVariation.y = 0.05f * (sin(i * Math::PI/180.f) + cos(i * Math::PI/180.f));
605 keyCosSinVariation.Add(key, cosSinVariation);
608 mPositionVarAnimation[3] = Animation::New(6.f);
609 mPositionVarAnimation[3].AnimateBetween(Property( mMetaballs[3].actor, mMetaballs[3].positionVarIndex ), keyCosSinVariation);
610 mPositionVarAnimation[3].SetLooping( true );
611 mPositionVarAnimation[3].Pause();
613 //Animations for gravity
614 for ( i = 0 ; i < METABALL_NUMBER ; i++)
616 mGravityAnimation[i] = Animation::New(25.f);
617 mGravityAnimation[i].AnimateBy( Property( mMetaballs[i].actor, mMetaballs[i].gravityIndex ), mGravity * 25.f * 3.f);
618 mGravityAnimation[i].SetLooping( false );
619 mGravityAnimation[i].Pause();
622 //Animation to decrease size of metaballs when there is no click
623 for ( i = 0 ; i < METABALL_NUMBER ; i++)
625 mRadiusDecAnimation[i] = Animation::New(25.f);
626 mRadiusDecAnimation[i].AnimateBy( Property( mMetaballs[i].actor, mMetaballs[i].radiusIndex ), -0.004f * 25.f * 3.f);
627 mRadiusDecAnimation[i].SetLooping( false );
628 mRadiusDecAnimation[i].Pause();
631 //Animation to grow the size of the metaballs the first second of the click
632 for ( i = 0 ; i < METABALL_NUMBER ; i++)
634 mRadiusIncFastAnimation[i] = Animation::New(0.3f);
635 mRadiusIncFastAnimation[i].AnimateBy( Property( mMetaballs[i].actor, mMetaballs[i].radiusIndex ), 0.06f);
636 mRadiusIncFastAnimation[i].SetLooping( false );
637 mRadiusIncFastAnimation[i].Pause();
639 mRadiusIncFastAnimation[0].FinishedSignal().Connect( this, &MetaballRefracController::LaunchRadiusIncSlowAnimations );
641 //Animation to grow the size of the metaballs afterwards
642 for ( i = 0 ; i < METABALL_NUMBER ; i++)
644 mRadiusIncSlowAnimation[i] = Animation::New(20.f);
645 mRadiusIncSlowAnimation[i].AnimateBy( Property( mMetaballs[i].actor, mMetaballs[i].radiusIndex ), 0.04f);
646 mRadiusIncSlowAnimation[i].SetLooping( false );
647 mRadiusIncSlowAnimation[i].Pause();
650 //keyframes of a sin function
651 KeyFrames keySin = KeyFrames::New();
653 for ( i = 0 ; i < 360 ; i++)
655 val = 0.01f * sin(i * Math::PI/180.f);
657 keySin.Add(key, val);
660 //Animation to change the size of the metaball
661 mRadiusVarAnimation[2] = Animation::New(8.f);
662 mRadiusVarAnimation[2].AnimateBetween(Property( mMetaballs[2].actor, mMetaballs[2].radiusVarIndex ), keySin);
663 mRadiusVarAnimation[2].SetLooping( true );
665 //keyframes of a cos function
666 KeyFrames keyCos = KeyFrames::New();
667 for ( i = 0 ; i < 360 ; i++)
669 val = 0.01f * cos(i * Math::PI/180.f);
671 keyCos.Add(key, val);
674 //Animation to change the size of the metaball
675 mRadiusVarAnimation[3] = Animation::New(8.f);
676 mRadiusVarAnimation[3].AnimateBetween(Property( mMetaballs[3].actor, mMetaballs[3].radiusVarIndex ), keyCos);
677 mRadiusVarAnimation[3].SetLooping( true );
681 * Function to launch the animation to get the metaball[1] back to the center
683 void MetaballRefracController::LaunchGetBackToPositionAnimation(Animation &source)
685 mMetaballPosVariationTo = Vector2(0,0);
687 mPositionVarAnimation[1] = Animation::New(1.f);
688 mPositionVarAnimation[1].SetLooping( false );
689 mPositionVarAnimation[1].AnimateTo(Property( mMetaballs[1].actor, mMetaballs[1].positionVarIndex ), Vector2(0,0));
690 mPositionVarAnimation[1].Play();
694 * Function to launch the gro slow radius for the metaballs, and also the small variations for metaball[2] and [3]
696 void MetaballRefracController::LaunchRadiusIncSlowAnimations(Animation &source)
698 for (int i = 0 ; i < METABALL_NUMBER ; i++)
700 mRadiusIncSlowAnimation[i].Play();
702 mPositionVarAnimation[2].Play();
703 mPositionVarAnimation[3].Play();
707 * Function to stop all animations related to the click of the user in the screen
709 void MetaballRefracController::StopClickAnimations()
711 for (int i = 0 ; i < METABALL_NUMBER ; i++)
713 mRadiusIncSlowAnimation[i].Stop();
714 mRadiusIncFastAnimation[i].Stop();
716 mPositionVarAnimation[1].Stop();
717 mPositionVarAnimation[2].Stop();
718 mPositionVarAnimation[3].Stop();
722 * Function to stop all animations related to the after click of the user in the screen
724 void MetaballRefracController::StopAfterClickAnimations()
726 for (int i = 0 ; i < METABALL_NUMBER ; i++)
728 mGravityAnimation[i].Stop();
729 mRadiusDecAnimation[i].Stop();
731 mMetaballs[i].radius = mMetaballs[i].initRadius;
733 mMetaballs[i].actor.SetProperty(mMetaballs[i].gravityIndex, Vector2(0,0));
734 mMetaballs[i].actor.SetProperty(mMetaballs[i].radiusIndex, mMetaballs[i].radius);
735 mMetaballs[i].actor.SetProperty(mMetaballs[i].radiusVarIndex, 0.f);
737 mRadiusVarAnimation[2].Stop();
738 mRadiusVarAnimation[3].Stop();
742 * Function that resets the sate of the different Metaballs
744 void MetaballRefracController::ResetMetaballsState()
746 mRendererRefraction.SetMaterial(mMaterialNormal);
748 for (int i = 0 ; i < METABALL_NUMBER ; i++)
750 mMetaballs[i].radius = mMetaballs[i].initRadius;
753 mMetaballPosVariationTo = Vector2(0,0);
754 mMetaballPosVariationFrom = Vector2(0,0);
755 mMetaballPosVariation = Vector2(0,0);
757 mGravityVar = Vector2(0,0);
761 * Function to set the actual position of the metaballs when the user clicks the screen
763 void MetaballRefracController::SetPositionToMetaballs(Vector2 & metaballCenter)
765 //We set the position for the metaballs based on click position
766 for (int i = 0 ; i < METABALL_NUMBER ; i++)
768 mMetaballs[i].position = metaballCenter;
769 mMetaballs[i].actor.SetProperty(mMetaballs[i].positionIndex, mMetaballs[0].position); // 0 y no i ?!?!?!
773 bool MetaballRefracController::OnTouch( Actor actor, const TouchEvent& touch )
775 const TouchPoint &point = touch.GetPoint(0);
776 float aspectR = mScreenSize.y / mScreenSize.x;
779 case TouchPoint::Down:
781 StopAfterClickAnimations();
782 for (int i = 0 ; i < METABALL_NUMBER ; i++)
783 mRadiusIncFastAnimation[i].Play();
784 mRadiusVarAnimation[2].Play();
785 mRadiusVarAnimation[3].Play();
787 //We draw with the refraction-composition shader
788 mRendererRefraction.SetMaterial(mMaterialRefraction);
790 mCurrentTouchPosition = point.screen;
792 //we use the click position for the metaballs
793 Vector2 metaballCenter = Vector2((point.screen.x / mScreenSize.x) - 0.5, (aspectR * (mScreenSize.y - point.screen.y) / mScreenSize.y) - 0.5) * 2.0;
794 SetPositionToMetaballs(metaballCenter);
797 case TouchPoint::Motion:
799 Vector2 displacement = point.screen - mCurrentTouchPosition;
800 mCurrentTouchPosition = point.screen;
802 mMetaballPosVariationTo.x += (displacement.x / mScreenSize.x) * 2.2;
803 mMetaballPosVariationTo.y += (- displacement.y / mScreenSize.y) * 2.2;
805 if (mPositionVarAnimation[1])
807 mPositionVarAnimation[1].FinishedSignal().Disconnect( this, &MetaballRefracController::LaunchGetBackToPositionAnimation );
808 mPositionVarAnimation[1].Stop();
810 mPositionVarAnimation[1] = Animation::New(1.f);
811 mPositionVarAnimation[1].SetLooping( false );
812 mPositionVarAnimation[1].AnimateTo(Property( mMetaballs[1].actor, mMetaballs[1].positionVarIndex ), mMetaballPosVariationTo);
813 mPositionVarAnimation[1].FinishedSignal().Connect( this, &MetaballRefracController::LaunchGetBackToPositionAnimation );
814 mPositionVarAnimation[1].Play();
816 //we use the click position for the metaballs
817 Vector2 metaballCenter = Vector2((point.screen.x / mScreenSize.x) - 0.5, (aspectR * (mScreenSize.y - point.screen.y) / mScreenSize.y) - 0.5) * 2.0;
818 SetPositionToMetaballs(metaballCenter);
822 case TouchPoint::Leave:
823 case TouchPoint::Interrupted:
825 //Stop click animations
826 StopClickAnimations();
828 //Launch out of screen animations
829 for (int i = 0 ; i < METABALL_NUMBER ; i++)
830 mGravityAnimation[i].Play();
832 for (int i = 0 ; i < METABALL_NUMBER ; i++)
833 mRadiusDecAnimation[i].Play();
844 void MetaballRefracController::OnKeyEvent(const KeyEvent& event)
846 if(event.state == KeyEvent::Down)
848 if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
858 //-----------------------------------------------------------------------------------------------
860 void RunTest( Application& application )
862 MetaballRefracController test( application );
864 application.MainLoop();
867 // Entry point for Linux & Tizen applications
869 int main( int argc, char **argv )
871 Application application = Application::New( &argc, &argv );
873 RunTest( application );