Peter M. Groen / dali-demo

Commit 3ef20b3f1c1e919858860f25f26c8885d364aad0

Authored by Paul Wisbey
1 parent 280e1b5a

Port the sparkle effect demo 

(Based on original demo by Xiangyin Ma)

Change-Id: I9ac5d9b9c4cb18a21d0a12fae0225af5527e405e
Inline Side-by-side
Showing 15 changed files with 993 additions and 2 deletions
demo/dali-demo.cpp
  View file @3ef20b3
... ... @@ -81,6 +81,7 @@ int DALI_EXPORT_API main(int argc, char **argv)
81 81 demo.AddExample(Example("mesh-visual.example", DALI_DEMO_STR_TITLE_MESH_VISUAL));
82 82 demo.AddExample(Example("primitive-shapes.example", DALI_DEMO_STR_TITLE_PRIMITIVE_SHAPES));
83 83 demo.AddExample(Example("styling.example", DALI_DEMO_STR_TITLE_STYLING));
  84 + demo.AddExample(Example("sparkle.example", DALI_DEMO_STR_TITLE_SPARKLE));
84 85  
85 86 demo.SortAlphabetically( true );
86 87  
... ...
examples/sparkle/sparkle-effect-example.cpp 0 → 100644
  View file @3ef20b3
  1 +/*
  2 + * Copyright (c) 2016 Samsung Electronics Co., Ltd.
  3 + *
  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
  7 + *
  8 + * http://www.apache.org/licenses/LICENSE-2.0
  9 + *
  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.
  15 + *
  16 + */
  17 +
  18 +#include <dali/dali.h>
  19 +#include <dali-toolkit/dali-toolkit.h>
  20 +
  21 +#include <sstream>
  22 +#include <algorithm>
  23 +#include <map>
  24 +
  25 +#include "shared/utility.h"
  26 +#include "sparkle-effect.h"
  27 +
  28 +using namespace Dali;
  29 +using Dali::Toolkit::ImageView;
  30 +
  31 +using namespace SparkleEffect;
  32 +
  33 +namespace // unnamed namespace
  34 +{
  35 +
  36 +//background image for normal status
  37 +const char * const CIRCLE_BACKGROUND_IMAGE( DEMO_IMAGE_DIR "sparkle_normal_background.png" );
  38 +//particle shape image
  39 +const char * const PARTICLE_IMAGE( DEMO_IMAGE_DIR "sparkle_particle.png" );
  40 +
  41 +float EaseOutSquare( float progress )
  42 +{
  43 + return 1.0f - (1.0f-progress) * (1.0f-progress);
  44 +}
  45 +
  46 +float CustomBounce( float progress )
  47 +{
  48 + float p = 1.f-progress;
  49 + p *=p;
  50 + return 17.68f*p*p*p*progress;
  51 +}
  52 +
  53 +float Mix( const Vector2& range, float a )
  54 +{
  55 + return range.x * a + range.y*(1.f-a)-0.001f;
  56 +}
  57 +
  58 +const Vector4 BACKGROUND_COLOR( 0.f, 0.f, 0.05f, 1.f );
  59 +
  60 +} // unnamed namespace
  61 +
  62 +// This example shows a sparkle particle effect
  63 +//
  64 +class SparkleEffectExample : public ConnectionTracker
  65 +{
  66 +public:
  67 +
  68 + /**
  69 + * Create the SparkleEffectExample
  70 + * @param[in] application The DALi application instance
  71 + */
  72 + SparkleEffectExample( Application& application )
  73 + : mApplication( application ),
  74 + mAnimationIndex( 0u ),
  75 + mShaking( false )
  76 + {
  77 + mApplication.InitSignal().Connect( this, &SparkleEffectExample::OnInit );
  78 + }
  79 +
  80 +private:
  81 +
  82 + /**
  83 + * Initialize the SparkleEffectExample
  84 + * @param[in] application The DALi application instance
  85 + */
  86 + void OnInit( Application& application )
  87 + {
  88 + Stage stage = Stage::GetCurrent();
  89 + stage.KeyEventSignal().Connect(this, &SparkleEffectExample::OnKeyEvent);
  90 + stage.SetBackgroundColor( BACKGROUND_COLOR );
  91 +
  92 + mCircleBackground = ImageView::New( CIRCLE_BACKGROUND_IMAGE );
  93 + mCircleBackground.SetParentOrigin( ParentOrigin::CENTER );
  94 + mCircleBackground.SetAnchorPoint( AnchorPoint::CENTER );
  95 +
  96 + stage.Add( mCircleBackground );
  97 +
  98 + mEffect = SparkleEffect::New();
  99 +
  100 + mMeshActor = CreateMeshActor();
  101 +
  102 + stage.Add( mMeshActor );
  103 +
  104 + mMeshActor.SetPosition( ACTOR_POSITION );
  105 + mMeshActor.SetScale( ACTOR_SCALE );
  106 +
  107 + mTapDetector = TapGestureDetector::New();
  108 + mTapDetector.Attach(mCircleBackground);
  109 + mTapDetector.DetectedSignal().Connect( this, &SparkleEffectExample::OnTap );
  110 +
  111 + mPanGestureDetector = PanGestureDetector::New();
  112 + mPanGestureDetector.DetectedSignal().Connect( this, &SparkleEffectExample::OnPan );
  113 + mPanGestureDetector.Attach( mCircleBackground );
  114 +
  115 + PlayWanderAnimation( 35.f );
  116 + }
  117 +
  118 + /**
  119 + * Create the mesh representing all the particles
  120 + */
  121 + Actor CreateMeshActor()
  122 + {
  123 + // shuffling to assign the color in random order
  124 + unsigned int* shuffleArray = new unsigned int[NUM_PARTICLE];
  125 + for( unsigned int i = 0; i<NUM_PARTICLE; i++ )
  126 + {
  127 + shuffleArray[i] = i;
  128 + }
  129 + std::random_shuffle(&shuffleArray[0],&shuffleArray[NUM_PARTICLE]);
  130 +
  131 + // Create vertices
  132 +
  133 + std::vector< Vertex > vertices;
  134 + std::vector< unsigned short > faces;
  135 +
  136 + for( unsigned int i = 0; i<NUM_PARTICLE; i++ )
  137 + {
  138 + float colorIndex = GetColorIndex( shuffleArray[i] );
  139 + AddParticletoMesh( vertices, faces, PATHS[i], colorIndex );
  140 + }
  141 +
  142 + delete [] shuffleArray;
  143 +
  144 + Property::Map vertexFormat;
  145 + vertexFormat["aTexCoord"] = Property::VECTOR2;
  146 + vertexFormat["aParticlePath0"] = Property::VECTOR2;
  147 + vertexFormat["aParticlePath1"] = Property::VECTOR2;
  148 + vertexFormat["aParticlePath2"] = Property::VECTOR2;
  149 + vertexFormat["aParticlePath3"] = Property::VECTOR2;
  150 + vertexFormat["aParticlePath4"] = Property::VECTOR2;
  151 + vertexFormat["aParticlePath5"] = Property::VECTOR2;
  152 +
  153 + PropertyBuffer propertyBuffer = PropertyBuffer::New( vertexFormat );
  154 + propertyBuffer.SetData( &vertices[0], vertices.size() );
  155 +
  156 + Geometry geometry = Geometry::New();
  157 + geometry.AddVertexBuffer( propertyBuffer );
  158 + geometry.SetIndexBuffer( &faces[0], faces.size() );
  159 + geometry.SetType( Geometry::TRIANGLES );
  160 +
  161 + Texture particleTexture = DemoHelper::LoadTexture( PARTICLE_IMAGE );
  162 + TextureSet textureSet = TextureSet::New();
  163 + textureSet.SetTexture( 0u, particleTexture );
  164 +
  165 + Renderer renderer = Renderer::New( geometry, mEffect );
  166 + renderer.SetTextures( textureSet );
  167 +
  168 + Actor meshActor = Actor::New();
  169 + meshActor.SetParentOrigin( ParentOrigin::CENTER );
  170 + meshActor.SetSize( 1, 1 );
  171 + meshActor.AddRenderer( renderer );
  172 +
  173 + return meshActor;
  174 + }
  175 +
  176 + /**
  177 + * Defines a rule to assign particle with a color according to its index
  178 + */
  179 + float GetColorIndex( unsigned int particleIndex )
  180 + {
  181 + unsigned int thereshold = 0;
  182 + for( unsigned int i = 0; i<NUM_COLOR; i++ )
  183 + {
  184 + thereshold += PARTICLE_COLORS[i].numParticle;
  185 + if( particleIndex < thereshold)
  186 + {
  187 + return i + Mix( PARTICLE_COLORS[i].AlphaRange, static_cast<float>(thereshold-particleIndex)/PARTICLE_COLORS[i].numParticle );
  188 + }
  189 + }
  190 + return NUM_COLOR-1;
  191 + }
  192 +
  193 + /**
  194 + * All a particle to the mesh by giving the moving path and color index
  195 + *
  196 + * Two triangles per particle
  197 + * 0---------3
  198 + * |\ |
  199 + * | \ |
  200 + * | \ |
  201 + * | \|
  202 + * 1---------2
  203 + *
  204 + * The information we need to pass in through attribute include:
  205 + *
  206 + * path which contains 12 integer
  207 + * ---- passed in 6 Vector2 attributes
  208 + *
  209 + * color index, particle index and textureCoor( (0,0) or (1,0) or (0,1) or (1,1) )
  210 + * ---- package these info into texCood attribute as: (+-colorIndex, +-particleIndex)
  211 + */
  212 + void AddParticletoMesh( std::vector< Vertex >& vertices,
  213 + std::vector< unsigned short >& faces,
  214 + MovingPath& movingPath,
  215 + float colorIndex )
  216 + {
  217 + unsigned int idx = vertices.size();
  218 +
  219 + // store the path into position and normal, which would be decoded inside the shader
  220 + Vector2 particlePath0( movingPath[0], movingPath[1] );
  221 + Vector2 particlePath1( movingPath[2], movingPath[3] );
  222 + Vector2 particlePath2( movingPath[4], movingPath[5] );
  223 + Vector2 particlePath3( movingPath[6], movingPath[7] );
  224 + Vector2 particlePath4( movingPath[8], movingPath[9] );
  225 + Vector2 particlePath5( movingPath[10], movingPath[11] );
  226 +
  227 + float particleIdx = static_cast<float>(idx/4 + 1); // count from 1
  228 + float colorIdx = colorIndex+1.f; // count from 1
  229 + vertices.push_back( Vertex( Vector2(-colorIdx, -particleIdx), particlePath0, particlePath1, particlePath2, particlePath3, particlePath4, particlePath5 ) );
  230 + vertices.push_back( Vertex( Vector2(-colorIdx, particleIdx), particlePath0, particlePath1, particlePath2, particlePath3, particlePath4, particlePath5 ) );
  231 + vertices.push_back( Vertex( Vector2( colorIdx, particleIdx), particlePath0, particlePath1, particlePath2, particlePath3, particlePath4, particlePath5 ) );
  232 + vertices.push_back( Vertex( Vector2( colorIdx, -particleIdx), particlePath0, particlePath1, particlePath2, particlePath3, particlePath4, particlePath5 ) );
  233 +
  234 + faces.push_back(idx);
  235 + faces.push_back(idx+1);
  236 + faces.push_back(idx+2);
  237 +
  238 + faces.push_back(idx);
  239 + faces.push_back(idx+2);
  240 + faces.push_back(idx+3);
  241 + }
  242 +
  243 + /*
  244 + * Main key event handler
  245 + */
  246 + void OnKeyEvent(const KeyEvent& event)
  247 + {
  248 + if(event.state == KeyEvent::Down)
  249 + {
  250 + if( IsKey( event, Dali::DALI_KEY_ESCAPE) || IsKey( event, Dali::DALI_KEY_BACK) )
  251 + {
  252 + mApplication.Quit();
  253 + }
  254 + }
  255 + }
  256 +
  257 + /**
  258 + * Callback of the TapGesture
  259 + */
  260 + void OnTap( Actor actor, const TapGesture& tap )
  261 + {
  262 + {
  263 + PlayTapAnimation(5.f, tap.localPoint);
  264 + }
  265 + }
  266 +
  267 + /**
  268 + * Callback of the PanGesture
  269 + */
  270 + void OnPan( Actor actor, const PanGesture& gesture )
  271 + {
  272 + if( gesture.state == Gesture::Finished )
  273 + {
  274 + switch(mAnimationIndex)
  275 + {
  276 + case 0:
  277 + {
  278 + PlayParticleFadeAnimation(0, NUM_PARTICLE, 0.f, 3.f );
  279 + break;
  280 + }
  281 + case 1:
  282 + {
  283 + PlayBreakAnimation(2.0f);
  284 + break;
  285 + }
  286 + case 2:
  287 + {
  288 + PlayShakeAnimation(0.5f, 2.5f);
  289 + break;
  290 + }
  291 + default:
  292 + {
  293 + break;
  294 + }
  295 + }
  296 +
  297 + mAnimationIndex = (mAnimationIndex+1)%3;
  298 + }
  299 + }
  300 +
  301 + /**
  302 + * Animate the particle position to make them wandering on the screen with 'seemingly' random fade in/out
  303 + * @param[in] duration The duration for the particle to move a cycle on the path. the bigger this value the slower the floating movement.
  304 + * @param[in] looping Infinite playing or not
  305 + */
  306 + void PlayWanderAnimation( float duration, bool looping = true )
  307 + {
  308 + Animation wanderAnimation= Animation::New(duration);
  309 + wanderAnimation.AnimateTo( Property( mEffect, PERCENTAGE_UNIFORM_NAME ), 1.f );
  310 + wanderAnimation.SetLooping(looping); // infinite playing
  311 +
  312 + wanderAnimation.Play();
  313 + }
  314 +
  315 + /**
  316 + * Accelerate the particle moving speed
  317 + * @param[in] cycle How many extra cycles to move during the animation
  318 + * @param[in] duration The duration for the animation
  319 + */
  320 + void PlayShakeAnimation( float cycle, float duration )
  321 + {
  322 + if( mShaking )
  323 + {
  324 + return;
  325 + }
  326 + DestroyAnimation( mTapAnimationAux );
  327 +
  328 + float accelaration = GetFloatUniformValue( ACCELARATION_UNIFORM_NAME );
  329 + mEffect.SetProperty( mEffect.GetPropertyIndex(ACCELARATION_UNIFORM_NAME), accelaration - int( accelaration) ); // Set the value as its fractional part
  330 + Animation shakeAnimation = Animation::New(duration);
  331 + shakeAnimation.AnimateBy( Property( mEffect, ACCELARATION_UNIFORM_NAME ), cycle, AlphaFunction::EASE_OUT );
  332 + shakeAnimation.FinishedSignal().Connect( this, &SparkleEffectExample::OnShakeAnimationFinished );
  333 +
  334 + shakeAnimation.Play();
  335 + mShaking = true;
  336 + }
  337 +
  338 + /**
  339 + * Animate the particles to appear from center and spread all over around
  340 + * @param[in] duration The duration for the animation
  341 + */
  342 + void PlayBreakAnimation( float duration )
  343 + {
  344 + if( GetFloatUniformValue(BREAK_UNIFORM_NAME) > 0.f )
  345 + {
  346 + return;
  347 + }
  348 +
  349 + // Stop the fading / tap animation before the breaking
  350 + DestroyAnimation( mFadeAnimation);
  351 + mTapIndices.x = mTapIndices.y;
  352 + mEffect.SetProperty( mEffect.GetPropertyIndex( TAP_INDICES_UNIFORM_NAME ), mTapIndices );
  353 + mEffect.SetProperty( mEffect.GetPropertyIndex( ACCELARATION_UNIFORM_NAME ), 0.f );
  354 +
  355 + // prepare the animation by setting the uniform to the required value
  356 + mEffect.SetProperty( mEffect.GetPropertyIndex( BREAK_UNIFORM_NAME ), 1.f );
  357 + mMeshActor.SetScale(0.01f);
  358 + mEffect.SetProperty( mEffect.GetPropertyIndex( "uScale" ), 0.01f );
  359 + mMeshActor.SetPosition( 0.f, 0.f, 1.f );
  360 +
  361 + Animation breakAnimation = Animation::New(duration*1.5f);
  362 + breakAnimation.AnimateTo( Property(mMeshActor, Actor::Property::SCALE), Vector3(ACTOR_SCALE,ACTOR_SCALE,ACTOR_SCALE), EaseOutSquare);
  363 + breakAnimation.AnimateTo( Property( mEffect, "uScale" ), ACTOR_SCALE, EaseOutSquare);
  364 + breakAnimation.AnimateTo( Property(mMeshActor, Actor::Property::POSITION), ACTOR_POSITION, EaseOutSquare);
  365 + breakAnimation.FinishedSignal().Connect( this, &SparkleEffectExample::OnBreakAnimationFinished );
  366 +
  367 + float timeUnit = duration/ (NUM_PARTICLE+1) /(NUM_PARTICLE+1) ;
  368 + std::ostringstream oss;
  369 + for(unsigned int i = 0; i<NUM_PARTICLE; i++)
  370 + {
  371 + oss.str("");
  372 + oss<< OPACITY_UNIFORM_NAME<< i << "]";
  373 + mEffect.SetProperty( mEffect.GetPropertyIndex( oss.str() ), 0.01f);
  374 + float timeSlice = timeUnit*i*i;
  375 + breakAnimation.AnimateTo( Property( mEffect, oss.str() ), 1.f, AlphaFunction::EASE_IN_OUT_SINE, TimePeriod( timeSlice*0.5f, timeSlice ) );
  376 + }
  377 +
  378 + breakAnimation.Play();
  379 + }
  380 +
  381 + /**
  382 + * Animate the particle opacity
  383 + * Particles with index between startIndex ~ startIndex+numParticle-1 fade to the target opacity one after another
  384 + * @param[in] startIndex The index of the first particle
  385 + * @param[in] numParticle The number of particle to change opacity
  386 + * @param[in] targetValue The final opacity
  387 + * @param[in] duration The duration for the animation
  388 + */
  389 + void PlayParticleFadeAnimation( unsigned int startIndex, unsigned int numParticle, float targetValue, float duration )
  390 + {
  391 + if( GetFloatUniformValue(BREAK_UNIFORM_NAME) > 0.f )
  392 + {
  393 + return;
  394 + }
  395 +
  396 + // start the opacity animation one particle after another gradually
  397 + float timeSlice = duration / (numParticle+1);
  398 + float fadeDuration = timeSlice>0.5f ? timeSlice : 0.5f;
  399 +
  400 + Animation fadeAnimation= Animation::New(duration+fadeDuration*2.f);
  401 + std::ostringstream oss;
  402 + for(unsigned int i = startIndex; i<numParticle; i++)
  403 + {
  404 + if( i>=NUM_PARTICLE ) break; // out of bound
  405 +
  406 + oss.str("");
  407 + oss<< OPACITY_UNIFORM_NAME<< i << "]";
  408 + fadeAnimation.AnimateTo(Property( mEffect, oss.str()), targetValue, TimePeriod( timeSlice*i, fadeDuration*2.f ));
  409 + }
  410 +
  411 + fadeAnimation.Play();
  412 + mFadeAnimation = fadeAnimation;
  413 + mFadeAnimation.FinishedSignal().Connect( this, &SparkleEffectExample::OnFadeAnimationFinished );
  414 + }
  415 +
  416 + /**
  417 + * Push the particles to the edge all around the circle then bounce back
  418 + * @param[in] duration The duration for the animation
  419 + * @param[in] tapPoint The position of the tap point
  420 + */
  421 + void PlayTapAnimation(float duration, const Vector2& tapPoint )
  422 + {
  423 + if( mTapIndices.y > mTapIndices.x && mTapAnimation.GetCurrentProgress() < 0.2f)
  424 + {
  425 + return;
  426 + }
  427 +
  428 + Animation animation= Animation::New(duration);
  429 + int idx = int(mTapIndices.y)%MAXIMUM_ANIMATION_COUNT;
  430 + mTapIndices.y += 1.f;
  431 +
  432 + std::ostringstream oss;
  433 + oss<< TAP_OFFSET_UNIFORM_NAME<< idx << "]";
  434 + mEffect.SetProperty( mEffect.GetPropertyIndex( oss.str() ), 0.f);
  435 + animation.AnimateTo( Property( mEffect, oss.str() ), 0.75f, CustomBounce);
  436 +
  437 + oss.str("");
  438 + oss<< TAP_POINT_UNIFORM_NAME<< idx << "]";
  439 + mEffect.SetProperty( mEffect.GetPropertyIndex( oss.str() ), tapPoint/ACTOR_SCALE);
  440 +
  441 + mEffect.SetProperty( mEffect.GetPropertyIndex( TAP_INDICES_UNIFORM_NAME ), mTapIndices);
  442 +
  443 + if(!mShaking)
  444 + {
  445 + mTapAnimationAux = Animation::New(duration*0.2f);
  446 + mTapAnimationAux.AnimateBy( Property( mEffect, ACCELARATION_UNIFORM_NAME ), 0.15f, AlphaFunction::EASE_IN_OUT );
  447 + mTapAnimationAux.Play();
  448 + }
  449 + animation.Play();
  450 + mTapAnimationIndexPair[animation] = static_cast<int>(mTapIndices.y -1.f);
  451 + animation.FinishedSignal().Connect( this, &SparkleEffectExample::OnTapAnimationFinished );
  452 + mTapAnimation = animation;
  453 + }
  454 +
  455 + /**
  456 + * Callback of the animation finished signal
  457 + */
  458 + void OnShakeAnimationFinished( Animation& animation)
  459 + {
  460 + mShaking = false;
  461 + }
  462 +
  463 + /**
  464 + * Callback of the animation finished signal
  465 + */
  466 + void OnFadeAnimationFinished( Animation& animation)
  467 + {
  468 + mFadeAnimation.Clear();
  469 + mFadeAnimation.Reset();
  470 + }
  471 +
  472 + /**
  473 + * Callback of the animation finished signal
  474 + */
  475 + void OnBreakAnimationFinished( Animation& animation)
  476 + {
  477 + mEffect.SetProperty( mEffect.GetPropertyIndex( BREAK_UNIFORM_NAME ), 0.f );
  478 + }
  479 +
  480 + /**
  481 + * Callback of the animation finished signal
  482 + */
  483 + void OnTapAnimationFinished( Animation& animation )
  484 + {
  485 + if( mTapAnimationIndexPair[animation] == static_cast<int>(mTapIndices.x) )
  486 + {
  487 + mTapIndices.x += 1.f;
  488 + if( mTapIndices.x >= mTapIndices.y )
  489 + {
  490 + mTapIndices = Vector2::ZERO;
  491 + }
  492 + mEffect.SetProperty( mEffect.GetPropertyIndex( TAP_INDICES_UNIFORM_NAME ), mTapIndices);
  493 + }
  494 +
  495 + mTapAnimationIndexPair.erase( animation );
  496 + if( mTapAnimationIndexPair.size() < 1 && mTapIndices != Vector2::ZERO)
  497 + {
  498 + mTapIndices = Vector2::ZERO;
  499 + mEffect.SetProperty( mEffect.GetPropertyIndex( TAP_INDICES_UNIFORM_NAME ), mTapIndices);
  500 + }
  501 +
  502 + animation.Clear();
  503 + animation.Reset();
  504 + }
  505 +
  506 + /**
  507 + * Helper retrieve a uniform value from the Sparkle effect shader
  508 + * @param[in] uniformName The uniform
  509 + * @return The float value
  510 + */
  511 + float GetFloatUniformValue( const std::string& uniformName )
  512 + {
  513 + float value;
  514 + mEffect.GetProperty(mEffect.GetPropertyIndex(uniformName)).Get(value);
  515 + return value;
  516 + }
  517 +
  518 + /**
  519 + * Terminate the given animation
  520 + */
  521 + void DestroyAnimation( Animation& animation )
  522 + {
  523 + if( animation )
  524 + {
  525 + animation.Clear();
  526 + animation.Reset();
  527 + }
  528 + }
  529 +
  530 +private:
  531 +
  532 + Application& mApplication;
  533 + Shader mEffect;
  534 + ImageView mCircleBackground;
  535 + Actor mMeshActor;
  536 +
  537 + PanGestureDetector mPanGestureDetector;
  538 + TapGestureDetector mTapDetector;
  539 +
  540 + Animation mFadeAnimation;
  541 + Animation mTapAnimation;
  542 + Animation mTapAnimationAux;
  543 +
  544 + Vector2 mTapIndices;
  545 + unsigned int mAnimationIndex;
  546 + bool mShaking;
  547 +
  548 + std::map< Animation, int > mTapAnimationIndexPair;
  549 +};
  550 +
  551 +void RunTest( Application& application )
  552 +{
  553 + SparkleEffectExample theApp( application );
  554 +
  555 + application.MainLoop();
  556 +}
  557 +
  558 +// Entry point for Linux & Tizen applications
  559 +//
  560 +int DALI_EXPORT_API main( int argc, char **argv )
  561 +{
  562 + Application application = Application::New( &argc, &argv );
  563 +
  564 + RunTest( application );
  565 +
  566 + return 0;
  567 +}
  568 +
... ...
examples/sparkle/sparkle-effect.h 0 → 100644
  View file @3ef20b3
  1 +#ifndef DALI_SPARKLE_EFFECT_H
  2 +#define DALI_SPARKLE_EFFECT_H
  3 +
  4 +/*
  5 + * Copyright (c) 2016 Samsung Electronics Co., Ltd.
  6 + *
  7 + * Licensed under the Apache License, Version 2.0 (the "License");
  8 + * you may not use this file except in compliance with the License.
  9 + * You may obtain a copy of the License at
  10 + *
  11 + * http://www.apache.org/licenses/LICENSE-2.0
  12 + *
  13 + * Unless required by applicable law or agreed to in writing, software
  14 + * distributed under the License is distributed on an "AS IS" BASIS,
  15 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 + * See the License for the specific language governing permissions and
  17 + * limitations under the License.
  18 + *
  19 + */
  20 +
  21 +#include <dali/dali.h>
  22 +#include <dali-toolkit/dali-toolkit.h>
  23 +
  24 +using namespace Dali;
  25 +using Dali::Toolkit::ImageView;
  26 +
  27 +/************************************************************/
  28 +/* Custom sparkle effect shader******************************/
  29 +/************************************************************/
  30 +
  31 +namespace SparkleEffect
  32 +{
  33 + // uniform which controls the position of particle on the path
  34 + const std::string PERCENTAGE_UNIFORM_NAME( "uPercentage" );
  35 + // uniform array of particle color, set their value as the PARTICLE_COLORS given below
  36 + const std::string PARTICLE_COLOR_UNIFORM_NAME("uParticleColors[");
  37 + // uniform array of particle opacity
  38 + const std::string OPACITY_UNIFORM_NAME("uOpacity[");
  39 + // uniform which offsets the path control point, with this values >=0, the paths are squeezed towards the GatheringPoint
  40 + const std::string ACCELARATION_UNIFORM_NAME("uAcceleration");
  41 + // uniform which indicates the ongoing tap animations
  42 + const std::string TAP_INDICES_UNIFORM_NAME("uTapIndices");
  43 + // uniform which controls how much the offset of the midpoints relative to the start/end points of the cubic bezier curve when the path is squeezed for tap animation
  44 + const std::string TAP_OFFSET_UNIFORM_NAME("uTapOffset[");
  45 + // uniform which gives the position of the tapping, in this way the particles will be pushed away from this point
  46 + const std::string TAP_POINT_UNIFORM_NAME("uTapPoint[");
  47 + // uniform which trigger the break animation, set to 1.0 when break animation is playing, otherwise set to 0.0
  48 + const std::string BREAK_UNIFORM_NAME("uBreak");
  49 +
  50 + /****************particle colors******************/
  51 +
  52 + struct ParticleColor
  53 + {
  54 + Vector3 RGB;
  55 + Vector2 AlphaRange;
  56 + unsigned int numParticle;
  57 + };
  58 +
  59 + ParticleColor PARTICLE_COLORS[]=
  60 + {
  61 + { Vector3( 0.f, 240.f, 255.f )/255.f, Vector2( 0.2f, 1.f ), 22 }, // 00f0ff, opacity 20%~100%
  62 + { Vector3( 89.f, 151.f, 239.f )/255.f, Vector2( 0.2f, 0.5f ), 12 }, // 5997ef, opacity 20%~50%
  63 + { Vector3( 181.f, 181.f, 207.f )/255.f, Vector2( 0.5f, 1.f ), 22 }, // b5b5cf, opacity 50%~100%
  64 + { Vector3( 147.f, 147.f, 170.f )/255.f, Vector2( 0.5f, 0.5f ), 22 }, // 9393aa, opacity 50%~50%
  65 + { Vector3( 145.f, 145.f, 201.f )/255.f, Vector2( 1.f, 1.f ), 12 }, // 91bdc9, opacity 100%~100%
  66 + { Vector3( 145.f, 145.f, 201.f )/255.f, Vector2( 0.2f, 0.2f ), 21 } // 91bdc9, opacity 20%~20%
  67 + };
  68 + const unsigned int NUM_COLOR( sizeof( PARTICLE_COLORS ) / sizeof( PARTICLE_COLORS[0] ) );
  69 +
  70 + /***************particle moving paths********************/
  71 +
  72 + typedef int MovingPath[12];
  73 +
  74 + // these paths are defined inside the circle which has the center at (250, 250) and the radius as 250
  75 + MovingPath PATHS[]=
  76 + { // each path is composed of two cubic b-curves: (p0, p1, p2, p3) & (p3, p4, p5, p0)
  77 + // p0 p1 p2 p3 p4 p5
  78 + { 280,273, 386,41, 489,141, 491,199, 494,256, 230,394 },
  79 + { 129,226, 357,120, 150,491, 291,406, 433,320, 47,283 },
  80 + { 96,264, 356,133, 446,196, 370,297, 294,399, -169,384 },
  81 + { 345,110, 359,186, 14,393, 4,247, -6,101, 321,-28 },
  82 + { 166,161, 128,353, 566,200, 487,304, 413,403, 203,-32 },
  83 + { 193,286, 106,331, 206,569, 334,477, 462,385, 279,240 },
  84 + { 336,247, 293,232, 301,465, 346,479, 390,493, 374,261 },
  85 + { 250,72, 314,72, 332,495, 250,497, 168,499, 161,72 },
  86 + { 48,387, 32,241, 452,558, 433,358, 411,121, 62,523 },
  87 + { 300,32, 159,27, 442,568, 186,492, -70,415, 551,41 },
  88 + { 479,150, 503,203, 216,403, 163,298, 110,193, 448,78 },
  89 + { 346,75, 311,97, 336,196, 389,160, 442,123, 383,51 },
  90 + { 90,61, 54,96, 218,373, 294,300, 370,227, 141,11 },
  91 + { 126,225, 240,280, 378,29, 221,16, 64,4, 11,170 },
  92 + { 308,101, 243,22, -10,271, 22,352, 49,422, 396,208 },
  93 + { 193,188, 174,302, 502,389, 500,250, 498,111, 212,72 },
  94 + { 227,3, 16,35, 577,309, 428,423, 279,537, 438,-28 },
  95 + { 410,58, 387,18, 22,179, 154,277, 286,374, 459,142 },
  96 + { 178,272, 109,299, 144,429, 218,396, 293,362, 221,254 },
  97 + { 247,46, 98,5, -91,357, 160,431, 412,505, 397,88 },
  98 + { 41,112, 22,144, 123,273, 158,187, 192,101, 75,56 },
  99 + { 8,300, 23,340, 267,294, 238,218, 209,142, -20,226 },
  100 + { 112,256, 24,270, -1,470, 154,433, 308,396, 201,242 },
  101 + { 212,277, 267,346, 509,202, 452,103, 398,8, 150,199 },
  102 + { 154,205, 146,287, 496,282, 492,194, 488,107, 160,140 },
  103 + { 281,350, 365,318, 415,476, 332,482, 248,489, 204,379 },
  104 + { 327,23, 346,81, 154,319, 123,207, 92,95, 313,-21 },
  105 + { 323,233, 283,307, 454,420, 478,354, 501,288, 374,136 },
  106 + { 318,186, 311,252, 488,248, 481,168, 474,87, 328,76 },
  107 + { 7,192, -10,270, 249,398, 269,307, 290,216, 25,111 },
  108 + { 148,22, 98,22, 25,458, 125,458, 225,458, 198,22 },
  109 + { 349,32, 307,39, 492,416, 399,446, 305,477, 460,16 },
  110 + { 147,474, 222,554, 392,154, 486,240, 581,325, 73,394 },
  111 + { 57,186, 13,200, 51,398, 114,374, 178,349, 97,174 },
  112 + { 257,192, 198,188, 162,345, 240,349, 319,354, 316,197 },
  113 + { 242,4, 283,21, 30,172, 81,215, 133,257, 209,-10 },
  114 + { 149,408, 165,442, 472,340, 444,275, 416,210, 120,348 },
  115 + { 106,271, 136,359, 483,370, 422,186, 360,2, 76,186 },
  116 + { 120,146, 29,224, 469,262, 346,390, 222,518, 393,-87 },
  117 + { 318,265, 415,280, 398,537, 247,491, 96,446, 222,249 },
  118 + { 171,275, 207,246, 274,469, 237,497, 199,525, 139,300 },
  119 + { 196,84, 135,105, 256,510, 334,486, 412,462, 280,55 },
  120 + { 485,314, 452,170, 158,606, 111,411, 55,179, 515,446 },
  121 + { 134,54, 266,4, 175,607, 392,451, 609,296, -100,144 },
  122 + { 3,229, -1,287, 334,383, 350,267, 366,150, 10,151 },
  123 + { 105,115, 146,125, 154,227, 92,209, 30,192, 62,105 },
  124 + { 343,20, 388,42, 323,357, 228,313, 132,269, 278,-10 },
  125 + { 362,186, 271,274, 60,82, 204,19, 349,-44, 453,97 },
  126 + { 145,128, 181,32, 501,185, 498,272, 495,347, 97,257 },
  127 + { 286,172, 342,274, 59,463, 16,331, -27,198, 231,69 },
  128 + { 194,7, 404,-32, -38,410, 140,469, 317,528, -16,45 },
  129 + { 39,120, 48,74, 445,109, 352,244, 259,379, 20,215 },
  130 + { 328,247, 402,250, 411,384, 330,377, 248,370, 281,244 },
  131 + { 189,56, 317,-31, 610,240, 396,392, 183,543, 61,144 },
  132 + { 402,53, 430,77, 376,231, 315,161, 255,91, 351,10 },
  133 + { 496,218, 494,260, 249,296, 251,214, 254,133, 498,139 },
  134 + { 381,210, 469,195, 557,376, 399,391, 241,407, 292,226 },
  135 + { 297,263, 267,346, -8,289, 14,176, 35,69, 331,168 },
  136 + { 329,187, 363,263, 30,371, 5,287, -19,203, 302,128 },
  137 + { 257,354, 168,351, 171,516, 252,496, 333,475, 340,356 },
  138 + { 106,60, 107,121, 366,284, 359,168, 352,52, 105,14 },
  139 + { 178,257, 240,314, 115,476, 71,421, 28,367, 98,182 },
  140 + { 163,213, 191,273, 22,327, 3,248, -17,170, 118,113 },
  141 + { 459,117, 500,185, 297,390, 248,311, 199,232, 416,46 },
  142 + { 270,3, 317,-14, 528,375, 434,407, 339,440, 223,19 },
  143 + { 88,76, 130,68, 78,485, 176,483, 274,482, -22,96 },
  144 + { 422,428, 378,528, 88,205, 26,317, -36,428, 467,328 },
  145 + { 414,127, 460,125, 489,325, 421,322, 353,320, 372,128 },
  146 + { 227,197, 281,174, 367,311, 294,340, 221,370, 173,220 },
  147 + { 180,14, 147,44, 436,104, 401,161, 366,219, 207,-10 },
  148 + { 400,367, 395,404, 71,406, 77,336, 82,265, 407,300 },
  149 + { 396,222, 396,316, 71,439, 70,245, 68,51, 396,132 },
  150 + { 342,109, 454,153, 49,332, 208,413, 367,494, 8,-23 },
  151 + { 147,167, 222,137, 266,169, 231,199, 197,229, 129,178 },
  152 + { 227,272, 310,243, 277,313, 322,266, 367,219, 207,313 },
  153 + { 279,192, 339,233, 396,211, 367,182, 338,152, 228,194 },
  154 + { 236,20, 283,75, 346,26, 338,71, 330,116, 207,17 },
  155 + { 129,83, 164,23, 158,14, 179,11, 200,8, 91,78 },
  156 + { 86,231, 129,293, 164,421, 104,348, 44,275, 66,200 },
  157 + { 193,328, 197,278, 240,348, 276,305, 311,263, 199,354 },
  158 + { 231,364, 241,209, 309,104, 326,236, 342,367, 225,424 },
  159 + { 414,230, 398,328, 446,445, 467,363, 489,281, 373,254 },
  160 + { 289,122, 332,123, 348,161, 322,158, 297,156, 275,125 },
  161 + { 142,235, 199,308, 402,229, 283,218, 164,206, 130,206 },
  162 + { 174,396, 210,387, 328,501, 246,455, 165,409, 138,394 },
  163 + { 288,388, 366,357, 372,458, 393,400, 414,343, 249,431 },
  164 + { 351,278, 409,369, 497,316, 437,288, 376,260, 351,243 },
  165 + { 87,134, 181,77, 311,121, 206,140, 101,160, 61,159 },
  166 + { 95,195, 126,208, 133,258, 110,236, 88,215, 95,195 },
  167 + { 140,293, 158,330, 169,275, 184,299, 198,323, 126,313 },
  168 + { 336,319, 383,357, 388,278, 393,333, 397,388, 311,325 },
  169 + { 338,107, 434,209, -37,469, 151,287, 338,104, 285,50 },
  170 + { 403,134, 446,182, 378,318, 386,233, 393,149, 360,98 },
  171 + { 366,82, 413,93, 416,158, 390,118, 364,78, 336,75 },
  172 + { 448,188, 448,230, 465,269, 470,225, 474,181, 448,177 },
  173 + { 121,398, 142,418, 126,475, 111,436, 96,396, 100,382 },
  174 + { 40,296, 90,352, 170,310, 143,350, 116,391, 7,300 },
  175 + { 25,203, 45,241, 70,204, 45,248, 19,293, 4,204 },
  176 + { 243,222, 225,275, 345,256, 296,237, 247,218, 249,199 },
  177 + { 159,149, 282,133, 284,199, 226,191, 169,184, 147,160 },
  178 + { 149,257, 290,322, 151,374, 166,338, 182,302, 116,263 },
  179 + { 255,285, 354,327, 234,287, 279,327, 323,367, 193,290 },
  180 + { 188,220, 353,190, 290,354, 348,293, 407,231, 152,248 },
  181 + { 305,122, 382,174, 402,229, 366,198, 329,167, 297,127 },
  182 + { 378,260, 406,267, 390,330, 384,293, 377,257, 366,263 },
  183 + { 178,396, 357,365, 273,461, 248,431, 223,401, 157,412 },
  184 + { 180,89, 258,88, 302,94, 255,115, 207,136, 166,96 },
  185 + { 81,197, 139,232, 39,257, 94,259, 150,261, 58,200 },
  186 + { 314,89, 378,40, 383,38, 389,42, 395,45, 267,90 },
  187 + { 371,141, 482,233, 508,244, 498,272, 488,299, 307,157 },
  188 + { 339,348, 361,465, 382,477, 406,442, 430,406, 269,369 }
  189 + };
  190 + const unsigned int NUM_PARTICLE( sizeof( PATHS ) / sizeof( PATHS[0] ) );
  191 +
  192 + const float PARTICLE_SIZE = 13.f;
  193 +
  194 + const float ACTOR_SCALE = 0.704f; // resize 500*500 to 352*352, a bit smaller than 360*360
  195 + const Vector3 ACTOR_POSITION( -176.f, -176.f, 1.f);
  196 +
  197 + const int MAXIMUM_ANIMATION_COUNT = 30;
  198 +
  199 + // Geometry format used by the SparkeEffect
  200 + struct Vertex
  201 + {
  202 + Vertex( const Vector2& texCoord,
  203 + const Vector2& aParticlePath0,
  204 + const Vector2& aParticlePath1,
  205 + const Vector2& aParticlePath2,
  206 + const Vector2& aParticlePath3,
  207 + const Vector2& aParticlePath4,
  208 + const Vector2& aParticlePath5 )
  209 + : aTexCoord( texCoord ),
  210 + aParticlePath0( aParticlePath0 ),
  211 + aParticlePath1( aParticlePath1 ),
  212 + aParticlePath2( aParticlePath2 ),
  213 + aParticlePath3( aParticlePath3 ),
  214 + aParticlePath4( aParticlePath4 ),
  215 + aParticlePath5( aParticlePath5 )
  216 + {
  217 + }
  218 +
  219 + Vector2 aTexCoord;
  220 + Vector2 aParticlePath0;
  221 + Vector2 aParticlePath1;
  222 + Vector2 aParticlePath2;
  223 + Vector2 aParticlePath3;
  224 + Vector2 aParticlePath4;
  225 + Vector2 aParticlePath5;
  226 + };
  227 +
  228 + /**
  229 + * Create a SparkleEffect object.
  230 + * @return A handle to a newly allocated SparkleEffect
  231 + */
  232 + Shader New()
  233 + {
  234 + std::string vertexShader = DALI_COMPOSE_SHADER(
  235 + precision highp float;\n
  236 + \n
  237 + attribute vec2 aTexCoord;\n
  238 + uniform mat4 uMvpMatrix;\n
  239 + varying vec2 vTexCoord;\n
  240 + \n
  241 + attribute vec2 aParticlePath0;\n
  242 + attribute vec2 aParticlePath1;\n
  243 + attribute vec2 aParticlePath2;\n
  244 + attribute vec2 aParticlePath3;\n
  245 + attribute vec2 aParticlePath4;\n
  246 + attribute vec2 aParticlePath5;\n
  247 + \n
  248 + uniform float uPercentage;\n
  249 + uniform float uPercentageMarked;\n
  250 + uniform vec3 uParticleColors[NUM_COLOR];\n
  251 + uniform float uOpacity[NUM_PARTICLE];\n
  252 + uniform vec2 uTapIndices;
  253 + uniform float uTapOffset[MAXIMUM_ANIMATION_COUNT];\n
  254 + uniform vec2 uTapPoint[MAXIMUM_ANIMATION_COUNT];\n
  255 + uniform float uAcceleration;\n
  256 + uniform float uRadius;\n
  257 + uniform float uScale;\n
  258 + uniform float uBreak;\n
  259 + \n
  260 + varying lowp vec4 vColor;\n
  261 + \n
  262 + void main()\n
  263 + {\n
  264 + // we store the particle index inside texCoord attribute
  265 + float idx = abs(aTexCoord.y)-1.0;\n
  266 + \n
  267 + // early out if the particle is invisible
  268 + if(uOpacity[int(idx)]<1e-5)\n
  269 + {\n
  270 + gl_Position = vec4(0.0);\n
  271 + vColor = vec4(0.0);\n
  272 + return;\n
  273 + }\n
  274 + \n
  275 + // As the movement along the b-curve has nonuniform speed with a uniform increasing parameter 'uPercentage'
  276 + // we give different particles the different 'percentage' to make them looks more random
  277 + float increment = idx / float(NUM_PARTICLE)*5.0;
  278 + float percentage = mod(uPercentage +uAcceleration+increment, 1.0);
  279 + \n
  280 + vec2 p0; vec2 p1; vec2 p2; vec2 p3;
  281 + // calculate the particle position by using the cubic b-curve equation
  282 + if(percentage<0.5)\n // particle on the first b-curve
  283 + {\n
  284 + p0 = aParticlePath0;\n
  285 + p1 = aParticlePath1;\n
  286 + p2 = aParticlePath2;\n
  287 + p3 = aParticlePath3;\n
  288 + }\n
  289 + else\n
  290 + {\n
  291 + p0 = aParticlePath3;\n
  292 + p1 = aParticlePath4;\n
  293 + p2 = aParticlePath5;\n
  294 + p3 = aParticlePath0;\n
  295 + }\n
  296 + float t = mod( percentage*2.0, 1.0);\n
  297 + vec2 position = (1.0-t)*(1.0-t)*(1.0-t)*p0 + 3.0*(1.0-t)*(1.0-t)*t*p1+3.0*(1.0-t)*t*t*p2 + t*t*t*p3;\n
  298 + \n
  299 + vec2 referencePoint = mix(p0,p3,0.5);\n
  300 + float maxAnimationCount = float(MAXIMUM_ANIMATION_COUNT);\n
  301 + \n
  302 + for( float i=uTapIndices.x; i<uTapIndices.y; i+=1.0 )\n
  303 + {
  304 + int id = int( mod(i+0.5,maxAnimationCount ) );\n
  305 + vec2 edgePoint = normalize(referencePoint-uTapPoint[id])*uRadius+vec2(uRadius);\n
  306 + position = mix( position, edgePoint, uTapOffset[id] ) ;\n
  307 + }\n
  308 + \n
  309 + position = mix( position, vec2( 250.0,250.0 ),uBreak*(1.0-uOpacity[int(idx)]) ) ;
  310 + \n
  311 + // vertex position on the mesh: (sign(aTexCoord.x), sign(aTexCoord.y))*PARTICLE_HALF_SIZE
  312 + gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uScale,
  313 + position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uScale,
  314 + 0.0, 1.0 );\n
  315 + \n
  316 + // we store the color index inside texCoord attribute
  317 + float colorIndex = abs(aTexCoord.x);
  318 + vColor.rgb = uParticleColors[int(colorIndex)-1];\n
  319 + vColor.a = fract(colorIndex) * uOpacity[int(idx)];\n
  320 + \n
  321 + // produce a 'seemingly' random fade in/out
  322 + percentage = mod(uPercentage+increment+0.15, 1.0);\n
  323 + float ramdomOpacity = (min(percentage, 0.25)-0.15+0.9-max(percentage,0.9))*10.0;\n
  324 + vColor.a *=ramdomOpacity;\n
  325 + \n
  326 + vTexCoord = clamp(aTexCoord, 0.0, 1.0);\n
  327 + }\n
  328 + );
  329 +
  330 + std::string fragmentShader = DALI_COMPOSE_SHADER(
  331 + precision highp float;\n
  332 + uniform sampler2D sTexture;\n
  333 + varying vec2 vTexCoord;\n
  334 + \n
  335 + varying lowp vec4 vColor;\n
  336 + \n
  337 + void main()\n
  338 + {\n
  339 + gl_FragColor = vColor;\n
  340 + gl_FragColor.a *= texture2D(sTexture, vTexCoord).a;\n
  341 + }\n
  342 + );
  343 +
  344 + std::ostringstream vertexShaderStringStream;
  345 + vertexShaderStringStream<< "#define NUM_COLOR "<< NUM_COLOR << "\n"
  346 + << "#define NUM_PARTICLE "<< NUM_PARTICLE << "\n"
  347 + << "#define PARTICLE_HALF_SIZE "<< PARTICLE_SIZE*ACTOR_SCALE/2.f << "\n"
  348 + << "#define MAXIMUM_ANIMATION_COUNT "<<MAXIMUM_ANIMATION_COUNT<<"\n"
  349 + << vertexShader;
  350 +
  351 + Shader handle = Shader::New( vertexShaderStringStream.str(), fragmentShader );
  352 +
  353 + // set the particle colors
  354 + std::ostringstream oss;
  355 + for( unsigned int i = 0; i < NUM_COLOR; i++ )
  356 + {
  357 + oss.str("");
  358 + oss<< PARTICLE_COLOR_UNIFORM_NAME<< i << "]";
  359 + handle.RegisterProperty(oss.str(), PARTICLE_COLORS[i].RGB);
  360 + }
  361 + handle.RegisterProperty( "uRadius", 250.f );
  362 + handle.RegisterProperty( "uScale", ACTOR_SCALE );
  363 +
  364 + // set the initial uniform values
  365 +
  366 + for( unsigned int i = 0; i < NUM_PARTICLE; i++ )
  367 + {
  368 + oss.str("");
  369 + oss<< OPACITY_UNIFORM_NAME << i << "]";
  370 + handle.RegisterProperty(oss.str(), 1.f);
  371 + }
  372 + handle.RegisterProperty( PERCENTAGE_UNIFORM_NAME, 0.f );
  373 + handle.RegisterProperty( ACCELARATION_UNIFORM_NAME, 0.f );
  374 + handle.RegisterProperty( BREAK_UNIFORM_NAME, 0.f);
  375 + handle.RegisterProperty( TAP_INDICES_UNIFORM_NAME, Vector2::ZERO);
  376 +
  377 + for( int i = 0; i < MAXIMUM_ANIMATION_COUNT; i++ )
  378 + {
  379 + oss.str("");
  380 + oss<< TAP_OFFSET_UNIFORM_NAME << i << "]";
  381 + handle.RegisterProperty(oss.str(), 0.f);
  382 +
  383 + oss.str("");
  384 + oss<< TAP_POINT_UNIFORM_NAME << i << "]";
  385 + handle.RegisterProperty(oss.str(), Vector2( 250.0f,250.0f ));
  386 + }
  387 +
  388 + return handle;
  389 + }
  390 +
  391 +}; // namespace SparkleEffect
  392 +
  393 +#endif // DALI_SPARKLE_EFFECT_H
... ...
resources/images/sparkle_normal_background.png 0 → 100755
View file @3ef20b3

31.5 KB
resources/images/sparkle_particle.png 0 → 100755
View file @3ef20b3

1.07 KB
resources/po/as.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;লিপি&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "স্ক্ৰ'ল কৰক"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "তাৰকা"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "শৈলী"
111 114  
... ...
resources/po/de.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;Scripting&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "Scroll-Ansicht"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "Funkeln"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "Styling"
111 114  
... ...
resources/po/en_GB.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;Script-based UI&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "Scroll View"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "Sparkle"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "Styling"
111 114  
... ...
resources/po/en_US.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;Script-based UI&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "Scroll View"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "Sparkle"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "Styling"
111 114  
... ...
resources/po/es.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;Interfaz definida por Script&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "Vista de desplazamiento"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "Brillar"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "Estilo"
111 114  
... ...
resources/po/ko.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;스크립팅&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "스크롤 뷰"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "불꽃"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "스타일링"
111 114  
... ...
resources/po/ml.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;സ്ക്രിപ്റ്റ്&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "സ്ക്രോള്ചെയ്യുക കാഴ്ച"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "നക്ഷത്ര"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "ശൈലി"
111 114  
... ... @@ -131,4 +134,4 @@ msgid &quot;DALI_DEMO_STR_TITLE_TEXT_SCROLLING&quot;
131 134 msgstr "ടെക്സ്റ്റ് സ്ക്രോളിംഗ്"
132 135  
133 136 msgid "DALI_DEMO_STR_TITLE_TILT_SENSOR"
134   -msgstr "ചെരിവ് സെൻസർ"
135 137 \ No newline at end of file
  138 +msgstr "ചെരിവ് സെൻസർ"
... ...
resources/po/ur.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;سکرپٹ&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "سکرول ویو"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "سٹار"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "سٹائل"
111 114  
... ...
resources/po/zn_CH.po
  View file @3ef20b3
... ... @@ -106,6 +106,9 @@ msgstr &quot;脚本用户界面&quot;
106 106 msgid "DALI_DEMO_STR_TITLE_SCROLL_VIEW"
107 107 msgstr "滚动视图"
108 108  
  109 +msgid "DALI_DEMO_STR_TITLE_SPARKLE"
  110 +msgstr "火花"
  111 +
109 112 msgid "DALI_DEMO_STR_TITLE_STYLING"
110 113 msgstr "样式"
111 114  
... ... @@ -131,4 +134,4 @@ msgid &quot;DALI_DEMO_STR_TITLE_TEXT_SCROLLING&quot;
131 134 msgstr "滚动文字"
132 135  
133 136 msgid "DALI_DEMO_STR_TITLE_TILT_SENSOR"
134   -msgstr "倾斜传感器"
135 137 \ No newline at end of file
  138 +msgstr "倾斜传感器"
... ...
shared/dali-demo-strings.h
  View file @3ef20b3
... ... @@ -68,6 +68,7 @@ extern &quot;C&quot;
68 68 #define DALI_DEMO_STR_TITLE_RENDERER_STENCIL dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_RENDERER_STENCIL")
69 69 #define DALI_DEMO_STR_TITLE_SCRIPT_BASED_UI dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_SCRIPT_BASED_UI")
70 70 #define DALI_DEMO_STR_TITLE_SCROLL_VIEW dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_SCROLL_VIEW")
  71 +#define DALI_DEMO_STR_TITLE_SPARKLE dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_SPARKLE")
71 72 #define DALI_DEMO_STR_TITLE_STYLING dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_STYLING")
72 73 #define DALI_DEMO_STR_TITLE_SUPER_BLUR_BLOOM dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_SUPER_BLUR_BLOOM")
73 74 #define DALI_DEMO_STR_TITLE_TEXTURED_MESH dgettext(DALI_DEMO_DOMAIN_LOCAL, "DALI_DEMO_STR_TITLE_TEXTURED_MESH")
... ... @@ -116,6 +117,7 @@ extern &quot;C&quot;
116 117 #define DALI_DEMO_STR_TITLE_RENDERER_STENCIL "Renderer Stencils"
117 118 #define DALI_DEMO_STR_TITLE_SCRIPT_BASED_UI "Script Based UI"
118 119 #define DALI_DEMO_STR_TITLE_SCROLL_VIEW "Scroll View"
  120 +#define DALI_DEMO_STR_TITLE_SPARKLE "Sparkle"
119 121 #define DALI_DEMO_STR_TITLE_STYLING "Styling"
120 122 #define DALI_DEMO_STR_TITLE_SUPER_BLUR_BLOOM "Super Blur and Bloom"
121 123 #define DALI_DEMO_STR_TITLE_TEXTURED_MESH "Mesh Texture"
... ...