optional/dali-toolkit/public-api/controls/bubble-effect/bubble-emitter.h

   1 #ifndef __DALI_TOOLKIT_BUBBLE_EMMITER_H__
   2 #define __DALI_TOOLKIT_BUBBLE_EMMITER_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 // INTERNAL INCLUDES
  22 #include <dali/dali.h>
  23 #include <dali-toolkit/public-api/controls/control.h>
  24
  25 namespace Dali DALI_IMPORT_API
  26 {
  27
  28 namespace Toolkit
  29 {
  30
  31 namespace Internal DALI_INTERNAL
  32 {
  33   /**
  34    * @brief BubbleEmitter implementation class.
  35    */
  36   class BubbleEmitter;
  37 }
  38
  39 /**
  40  * @brief BubbleEmitter is used to display lots of moving bubbles on the stage.
  41  *
  42  * This is done by applying BubbleEffect to multiple specifically created meshActors.
  43  */
  44 class BubbleEmitter : public Control
  45 {
  46 public:
  47
  48   /**
  49    * @brief Create an empty BubbleEmitter handle.
  50    */
  51   BubbleEmitter();
  52
  53   /**
  54    * @brief Virtual destructor.
  55    */
  56   ~BubbleEmitter();
  57
  58   /**
  59    * @brief Create an initialized BubbleEmitter.
  60    *
  61    * @param[in] winSize The size of the bubble moving area, usually the same size as the background image actor.
  62    * @param[in] shapeImage The alpha channnel of this texture defines the bubble shape.
  63    * @param[in] maximumNumberOfBubble The maximum number of bubble needed.
  64    * @param[in] bubbleSizeRange The size range of the bubbles; x component is the low bound, and y component is the up bound.
  65    * @return The initialized BubbleEmitter object.
  66    */
  67   static BubbleEmitter New( const Vector2& winSize,
  68                             Image shapeImage,
  69                             unsigned int maximumNumberOfBubble,
  70                             const Vector2& bubbleSizeRange );
  71
  72
  73   /**
  74    * @brief Copy constructor.
  75    *
  76    * Creates another handle that points to the same real object
  77    * @param[in] handle The handle to copy
  78    */
  79   BubbleEmitter( const BubbleEmitter& handle );
  80
  81   /**
  82    * @brief Assignment operator.
  83    *
  84    * Changes this handle to point to another real object
  85    * @param[in] rhs The object to point at
  86    * @return A reference to this
  87    */
  88   BubbleEmitter& operator=( const BubbleEmitter& rhs );
  89
  90   /**
  91    * @brief Downcast an Object handle to SuperBlurView.
  92    *
  93    * If handle points to a BubbleEmitter, the downcast produces valid handle.
  94    * If not, the returned handle is left uninitialized.
  95    * @param[in] handle Handle to an object
  96    * @return handle to a BubbleEmitter or an uninitialized handle
  97    */
  98   static BubbleEmitter DownCast( BaseHandle handle );
  99
 100   /**
 101    * @brief Return the root actor of all bubbles, should then be added to stage.
 102    *
 103    * @return The bubble root actor.
 104    */
 105   Actor GetRootActor();
 106
 107   /**
 108    * @brief Set Background image.
 109    *
 110    * The bubbles pick color from this image with HSV values adjusted.
 111    * @param[in] bgImage The background image which provide color to bubbles.
 112    * @param[in] hsvDelta The hsv channel difference used to adjust the background image color.
 113    *            If set these vector as Vector3::Zero, original colors are used.
 114    */
 115   void SetBackground( Image bgImage, const Vector3& hsvDelta );
 116
 117   /**
 118    * @brief Set bubble shape.
 119    *
 120    * The bubble mesh is a rectangular patch, but its displayed shape is decided by the alpha channel of the shape image.
 121    * @param[in] shapeImage The image whose alpha channel defines the bubble shape.
 122    */
 123   void SetShapeImage( Image shapeImage );
 124
 125   /**
 126    * @brief Set the scale factor applied to all the bubbles.
 127    *
 128    * @param [in] scale The scale factor applied on bubbles.
 129    */
 130   void SetBubbleScale( float scale );
 131
 132   /**
 133    * @brief Set the density of the bubble.
 134    *
 135    * Ideally every bubble's moving track is controlled by different uniforms in BubbleEffect shaders.
 136    * To increase the density, 'density' number of bubbles are sharing one group of uniforms, but with random offsets between these bubbles.
 137    * The available density is one to nine. The default density is five.
 138    * By set the density bigger than one, instead of emit one bubble each time, a 'density' number of bubbles are emitted.
 139    * @param[in] density The density of the bubble.
 140    */
 141   void SetBubbleDensity( unsigned int density );
 142
 143   /**
 144    * @brief Enable different blending mode for rendering.
 145    *
 146    * @param[in] enable If false, the default blending function for RenderableActor is used.
 147    */
 148   void SetBlendMode( bool enable );
 149
 150   /**
 151    * @brief Add a bubble movement to the animation.
 152    *
 153    * @param[in] animation The animation reference.
 154    * By passing the animation into BubbleEmitter, the animation's duration and how many bubbles contained within this animation are freely decided in App.
 155    * @param[in] emitPosition The start position of the bubble movement.
 156    * @param[in] direction The direction used to constrain the bubble to move in an adjacent direction around it.
 157    * @param[in] displacement The displacement used to bound the moving distance of the bubble.
 158    */
 159   void EmitBubble( Animation& animation, const Vector2& emitPosition, const Vector2& direction, const Vector2& displacement );
 160
 161   /**
 162    * @brief Start an animation to enlarge every activated bubble's size and moving speed.
 163    *
 164    * @param[in] duration The duration of the animation
 165    * @param[in] multiple The bubble size and moving speed will be increased gradually to multiple speed during the animation.
 166    */
 167   void StartExplosion( float duration, float multiple );
 168
 169   /**
 170    * @brief Reset all the parameters controlling the bubbles after animation.
 171    */
 172   void Restore();
 173
 174 public: // Not intended for developer use
 175
 176   /**
 177    * @brief Creates a handle using the Toolkit::Internal implementation.
 178    *
 179    * @param[in]  implementation  The Control implementation.
 180    */
 181   DALI_INTERNAL BubbleEmitter(Internal::BubbleEmitter& implementation);
 182
 183   /**
 184    * @brief Allows the creation of this Control from an Internal::CustomActor pointer.
 185    *
 186    * @param[in]  internal  A pointer to the internal CustomActor.
 187    */
 188   DALI_INTERNAL BubbleEmitter(Dali::Internal::CustomActor* internal);
 189 };
 190
 191 } // namespace Toolkit
 192
 193 } // namespace Dali
 194
 195 #endif /* __DALI_TOOLKIT_BUBBLE_EMMITER_H__ */