dali-toolkit/internal/controls/bubble-effect/bubble-actor.cpp

   1 /*
   2  * Copyright (c) 2015 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 // CLASS HEADER
  19 #include "bubble-actor.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <cmath>
  23 #include <sstream>
  24
  25 // INTERNAL INCLUDES
  26
  27 namespace
  28 {
  29
  30 /**
  31  * Register a property and map it as uniform.
  32  * @param[in] handle The handle to register new property.
  33  * @param[in] propertyName The name of the property.
  34  * @param[in] unifoemName The name of the uniform.
  35  * @param[in] value The initial value of the property.
  36  * @return The index of theproperty
  37  */
  38 Dali::Property::Index RegisterUniform( Dali::Handle& handle,
  39                                        const std::string& propertyName,
  40                                        const std::string& uniformName,
  41                                        Dali::Property::Value value)
  42 {
  43   Dali::Property::Index propertyIndex = handle.RegisterProperty( propertyName, value );
  44   handle.AddUniformMapping( propertyIndex, uniformName );
  45
  46   return propertyIndex;
  47 }
  48
  49 }// end LOCAL_STUFF
  50
  51 namespace Dali
  52 {
  53
  54 namespace Toolkit
  55 {
  56
  57 namespace Internal
  58 {
  59
  60 BubbleActor::BubbleActor( unsigned int numberOfBubble,
  61                           const Vector2& movementArea)
  62 : mMovementArea( movementArea ),
  63   mNumBubble( numberOfBubble )
  64 {
  65   mActor = Actor::New();
  66 }
  67
  68 void BubbleActor::MakeRenderable( Geometry geometry, Material material  )
  69 {
  70   if( mRenderer )
  71   {
  72     // This function is supposed to be called once
  73     return;
  74   }
  75
  76   mRenderer = Renderer::New( geometry, material );
  77
  78   mActor.AddRenderer( mRenderer );
  79   mActor.SetSize( mMovementArea );
  80   mActor.SetParentOrigin(ParentOrigin::TOP_LEFT);
  81
  82   // register uniforms
  83   mIndexGravity = RegisterUniform( mActor, "gravity", "uGravity", 50.f );
  84   mIndexDynamicScale = RegisterUniform( mActor, "dynamic-scale", "uDynamicScale", 1.f );
  85
  86   mIndexInvertedMovementArea = RegisterUniform( mActor, "inverted-movement-area", "uInvertedMovementArea", Vector2(1.f,1.f) / mMovementArea );
  87
  88   srand(time(NULL));
  89   mIndicesOffset.resize(9);
  90   int offset = mMovementArea.Length() / 10.f;
  91   mIndicesOffset[0] = RegisterUniform(mActor, "offset-0", "offset[0]", Vector2(0.f,0.f));
  92   mIndicesOffset[1] = RegisterUniform(mActor, "offset-1", "offset[1]", Vector2(rand()%offset,rand()%offset) );
  93   mIndicesOffset[2] = RegisterUniform(mActor, "offset-2", "offset[2]", Vector2(rand()%offset,-rand()%offset) );
  94   mIndicesOffset[3] = RegisterUniform(mActor, "offset-3", "offset[3]", Vector2(-rand()%offset,rand()%offset) );
  95   mIndicesOffset[4] = RegisterUniform(mActor, "offset-4", "offset[4]", Vector2(-rand()%offset,-rand()%offset) );
  96   mIndicesOffset[5] = RegisterUniform(mActor, "offset-5", "offset[5]", Vector2(rand()%offset,0.f));
  97   mIndicesOffset[6] = RegisterUniform(mActor, "offset-6", "offset[6]", Vector2(-rand()%offset,0.f));
  98   mIndicesOffset[7] = RegisterUniform(mActor, "offset-7", "offset[7]", Vector2(0.f,rand()%offset));
  99   mIndicesOffset[8] = RegisterUniform(mActor, "offset-8", "offset[8]", Vector2(0.f,-rand()%offset));
 100
 101   Vector4 zeroVector;
 102   mIndiceStartEndPos.resize( mNumBubble );
 103   mIndicesPercentage.resize( mNumBubble );
 104   for( unsigned int i=0; i<mNumBubble; i++ )
 105   {
 106     std::ostringstream ossProperty;
 107     ossProperty<< "start-end-position-"<< i;
 108
 109     std::ostringstream ossUniform;
 110     ossUniform<< "uStartAndEndPos["<< i << "]";
 111     mIndiceStartEndPos[i] = RegisterUniform( mActor, ossProperty.str(), ossUniform.str(), zeroVector );
 112
 113     ossProperty.str("");
 114     ossProperty<< "percentage-"<< i;
 115
 116     ossUniform.str("");
 117     ossUniform<< "uPercentage["<< i << "]";
 118     mIndicesPercentage[i] = RegisterUniform( mActor, ossProperty.str(), ossUniform.str(), 0.f );
 119   }
 120 }
 121
 122 Actor BubbleActor::GetMeshActor()
 123 {
 124   return mActor;
 125 }
 126
 127 void BubbleActor::SetGeometry( Geometry geometry )
 128 {
 129   mRenderer.SetGeometry( geometry );
 130 }
 131
 132 void BubbleActor::SetMovementArea( const Vector2& movementArea )
 133 {
 134   if( movementArea == mMovementArea)
 135   {
 136     return;
 137   }
 138
 139   mMovementArea = movementArea;
 140   mActor.SetSize( mMovementArea );
 141   mActor.SetProperty( mIndexInvertedMovementArea, Vector2(1.f,1.f) / mMovementArea );
 142
 143   int offset = mMovementArea.Length() / 10.f;
 144   mActor.SetProperty( mIndicesOffset[1], Vector2(rand()%offset,rand()%offset) );
 145   mActor.SetProperty( mIndicesOffset[2], Vector2(rand()%offset,-rand()%offset) );
 146   mActor.SetProperty( mIndicesOffset[3], Vector2(-rand()%offset,rand()%offset) );
 147   mActor.SetProperty( mIndicesOffset[4], Vector2(-rand()%offset,-rand()%offset) );
 148   mActor.SetProperty( mIndicesOffset[5], Vector2(rand()%offset,0.f));
 149   mActor.SetProperty( mIndicesOffset[6], Vector2(-rand()%offset,0.f));
 150   mActor.SetProperty( mIndicesOffset[7], Vector2(0.f,rand()%offset));
 151   mActor.SetProperty( mIndicesOffset[8], Vector2(0.f,-rand()%offset));
 152 }
 153
 154 void BubbleActor::SetStartAndEndPosition( unsigned int index, const Vector4& startAndEndPosition )
 155 {
 156   mActor.SetProperty( mIndiceStartEndPos[index], startAndEndPosition );
 157 }
 158
 159 void BubbleActor::SetPercentage( unsigned int index, float percentage )
 160 {
 161   mActor.SetProperty( mIndicesPercentage[index], percentage );
 162 }
 163
 164 void BubbleActor::SetGravity( float gravity )
 165 {
 166   mActor.SetProperty( mIndexGravity, gravity );
 167 }
 168
 169 void BubbleActor::SetDynamicScale( float scale )
 170 {
 171   mActor.SetProperty( mIndexDynamicScale, scale );
 172 }
 173
 174 Property BubbleActor::GetPercentageProperty( unsigned int index )
 175 {
 176   return Property( mActor, mIndicesPercentage[index] );
 177 }
 178
 179 void BubbleActor::ResetProperties()
 180 {
 181   Vector4 zeroVector;
 182   for( unsigned int i=0; i<mNumBubble; i++ )
 183   {
 184     SetPercentage( i, 0.f);
 185     SetStartAndEndPosition( i, zeroVector );
 186   }
 187 }
 188
 189 } // namespace Internal
 190
 191 } // namespace Toolkit
 192
 193 } // namespace Dali