examples/radial-menu/radial-sweep-view-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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 "radial-sweep-view-impl.h"
  19
  20 using namespace Dali;
  21
  22 namespace
  23 {
  24
  25 /**
  26  * Method to project a point on a circle of radius halfSide at given
  27  * angle onto a square of side 2 * halfSide
  28  */
  29 Vector3 CircleSquareProjection( Degree angle, float halfSide )
  30 {
  31   Vector3 position(0.0f, 0.0f, 0.0f);
  32   Radian angleInRadians(angle);
  33
  34   //  135  90   45
  35   //     +--+--+
  36   //     | \|/ |
  37   // 180 +--+--+ 0
  38   //     | /|\ |
  39   //     +--+--+
  40   //  225  270  315
  41   if( angle >= 45.0f && angle < 135.0f )
  42   {
  43     position.x = halfSide * cosf(angleInRadians) / sinf(angleInRadians);
  44     position.y = -halfSide;
  45   }
  46   else if( angle >= 135.0f && angle < 225.0f )
  47   {
  48     position.x = -halfSide;
  49     position.y = halfSide * sinf(angleInRadians) / cosf(angleInRadians);
  50   }
  51   else if( angle >= 225.0f && angle < 315.0f )
  52   {
  53     position.x = -halfSide * cosf(angleInRadians) / sinf(angleInRadians);
  54     position.y =  halfSide;
  55   }
  56   else
  57   {
  58     position.x = halfSide;
  59     position.y = -halfSide * sinf(angleInRadians) / cosf(angleInRadians);
  60   }
  61   return position;
  62 }
  63
  64 float HoldZeroFastEaseInOutHoldOne(float progress)
  65 {
  66   if( progress < 0.2f)
  67   {
  68     return 0.0f;
  69   }
  70   else if(progress < 0.5f)
  71   {
  72     return AlphaFunctions::EaseIn((progress-0.2) / 0.3f) * 0.5f;
  73   }
  74   else if(progress < 0.8f)
  75   {
  76     return AlphaFunctions::EaseOut((progress - 0.5f) / 0.3f) * 0.5f + 0.5f;
  77   }
  78   else
  79   {
  80     return 1.0f;
  81   }
  82 }
  83
  84 struct SquareFanConstraint
  85 {
  86   SquareFanConstraint(int sideIndex)
  87   : mSideIndex(sideIndex)
  88   {
  89   }
  90
  91   Vector3 operator()( const Vector3& current, const PropertyInput& start, const PropertyInput& rotation )
  92   {
  93     float degree = fmodf((start.GetFloat() + rotation.GetFloat()), 360.0f);
  94     if(degree < 0.0f)
  95     {
  96       degree += 360.0f;
  97     }
  98
  99     float startAngle = (90.0f*mSideIndex)-45.0f;
 100     float endAngle = (90.0f*mSideIndex)+45.0f;
 101     if(degree < startAngle)
 102     {
 103       return Vector3::ZERO;
 104     }
 105     else if( degree >= endAngle )
 106     {
 107       degree = endAngle;
 108     }
 109     Vector3 pos = CircleSquareProjection(Degree(degree), 0.5f);
 110     pos.x = -pos.x; // Inverting X makes the animation go anti clockwise from left center
 111     return pos;
 112   }
 113
 114   int mSideIndex;
 115 };
 116
 117 } // anonymous namespace
 118
 119
 120 RadialSweepView RadialSweepViewImpl::New( )
 121 {
 122   return New( 2.0f, 100.0f, Degree(0.0f), Degree(0.0f), Degree(0.0f), Degree(359.999f) );
 123 }
 124
 125
 126 RadialSweepView RadialSweepViewImpl::New( float duration, float diameter, Degree initialAngle, Degree finalAngle, Degree initialSector, Degree finalSector )
 127 {
 128   RadialSweepViewImpl* impl= new RadialSweepViewImpl(duration, diameter, initialAngle, finalAngle, initialSector, finalSector);
 129   RadialSweepView handle = RadialSweepView(*impl);
 130   return handle;
 131 }
 132
 133 RadialSweepViewImpl::RadialSweepViewImpl( float duration, float diameter, Degree initialAngle, Degree finalAngle, Degree initialSector, Degree finalSector )
 134 : Control( CONTROL_BEHAVIOUR_NONE ),
 135   mDuration(duration),
 136   mDiameter(diameter),
 137   mInitialAngle(initialAngle),
 138   mFinalAngle(finalAngle),
 139   mInitialSector(initialSector),
 140   mFinalSector(finalSector),
 141   mInitialActorAngle(0),
 142   mFinalActorAngle(0),
 143   mEasingFunction(HoldZeroFastEaseInOutHoldOne),
 144   mStartAngleIndex(Property::INVALID_INDEX),
 145   mRotationAngleIndex(Property::INVALID_INDEX),
 146   mRotateActorsWithStencil(false),
 147   mRotateActors(false)
 148 {
 149 }
 150
 151 void RadialSweepViewImpl::SetDuration(float duration)
 152 {
 153   mDuration = duration;
 154 }
 155
 156 void RadialSweepViewImpl::SetEasingFunction( Dali::AlphaFunction easingFunction )
 157 {
 158   mEasingFunction = easingFunction;
 159 }
 160
 161 void RadialSweepViewImpl::SetDiameter(float diameter)
 162 {
 163   mDiameter = diameter;
 164 }
 165
 166 void RadialSweepViewImpl::SetInitialAngle( Dali::Degree initialAngle)
 167 {
 168   mInitialAngle = initialAngle;
 169 }
 170
 171 void RadialSweepViewImpl::SetFinalAngle( Dali::Degree finalAngle)
 172 {
 173   mFinalAngle = finalAngle;
 174 }
 175
 176 void RadialSweepViewImpl::SetInitialSector( Dali::Degree initialSector)
 177 {
 178   mInitialSector = initialSector;
 179 }
 180
 181 void RadialSweepViewImpl::SetFinalSector( Dali::Degree finalSector)
 182 {
 183   mFinalSector = finalSector;
 184 }
 185
 186 void RadialSweepViewImpl::SetInitialActorAngle( Dali::Degree initialAngle )
 187 {
 188   mInitialActorAngle = initialAngle;
 189   mRotateActors = true;
 190 }
 191
 192 void RadialSweepViewImpl::SetFinalActorAngle( Dali::Degree finalAngle )
 193 {
 194   mFinalActorAngle = finalAngle;
 195   mRotateActors = true;
 196 }
 197
 198 float RadialSweepViewImpl::GetDuration( )
 199 {
 200   return mDuration;
 201 }
 202
 203 float RadialSweepViewImpl::GetDiameter( )
 204 {
 205   return mDiameter;
 206 }
 207
 208 Dali::Degree RadialSweepViewImpl::GetInitialAngle( )
 209 {
 210   return mInitialAngle;
 211 }
 212
 213 Dali::Degree RadialSweepViewImpl::GetFinalAngle( )
 214 {
 215   return mFinalAngle;
 216 }
 217
 218 Dali::Degree RadialSweepViewImpl::GetInitialSector( )
 219 {
 220   return mInitialSector;
 221 }
 222
 223 Dali::Degree RadialSweepViewImpl::GetFinalSector( )
 224 {
 225   return mFinalSector;
 226 }
 227
 228 Dali::Degree RadialSweepViewImpl::GetInitialActorAngle( )
 229 {
 230   return mInitialActorAngle;
 231 }
 232
 233 Dali::Degree RadialSweepViewImpl::GetFinalActorAngle(  )
 234 {
 235   return mFinalActorAngle;
 236 }
 237
 238 void RadialSweepViewImpl::RotateActorsWithStencil(bool rotate)
 239 {
 240   mRotateActorsWithStencil = rotate;
 241 }
 242
 243 void RadialSweepViewImpl::Add(Actor actor)
 244 {
 245   if( ! mLayer )
 246   {
 247     mLayer = Layer::New();
 248     Self().Add(mLayer);
 249     mLayer.SetSize( Stage::GetCurrent().GetSize() );
 250     mLayer.SetPositionInheritanceMode(USE_PARENT_POSITION);
 251   }
 252
 253   mLayer.Add(actor);
 254 }
 255
 256 void RadialSweepViewImpl::Activate( Animation anim, float offsetTime, float duration )
 257 {
 258   bool startAnimation=false;
 259   if( ! anim )
 260   {
 261     mAnim = Animation::New( mDuration );
 262     anim = mAnim;
 263     startAnimation = true;
 264   }
 265
 266   if( ! mStencilActor )
 267   {
 268     CreateStencil( mInitialSector );
 269     mLayer.Add( mStencilActor );
 270     mStencilActor.SetSize(mDiameter, mDiameter);
 271   }
 272
 273   mStencilActor.SetRotation( Degree(mInitialAngle), Vector3::ZAXIS );
 274   mStencilActor.SetProperty( mRotationAngleIndex, static_cast<float>(mInitialSector) );
 275
 276   if( mRotateActors )
 277   {
 278     for(unsigned int i=0, count=mLayer.GetChildCount(); i<count; i++)
 279     {
 280       Actor actor = mLayer.GetChildAt(i);
 281       if( actor != mStencilActor )
 282       {
 283         anim.RotateTo( actor, mInitialActorAngle, Vector3::ZAXIS );
 284       }
 285     }
 286   }
 287
 288   anim.AnimateTo( Property( mStencilActor, mRotationAngleIndex ), static_cast<float>(mFinalSector), mEasingFunction, TimePeriod( offsetTime, duration) );
 289   anim.RotateTo( mStencilActor, mFinalAngle, Vector3::ZAXIS, mEasingFunction, offsetTime, duration );
 290
 291   if( mRotateActorsWithStencil )
 292   {
 293     for(unsigned int i=0, count=mLayer.GetChildCount(); i<count; i++)
 294     {
 295       Actor actor = mLayer.GetChildAt(i);
 296       if( actor != mStencilActor )
 297       {
 298         anim.RotateTo( actor, Degree(mFinalAngle - mInitialAngle), Vector3::ZAXIS, mEasingFunction, offsetTime, duration );
 299       }
 300     }
 301   }
 302   else if( mRotateActors )
 303   {
 304     for(unsigned int i=0, count=mLayer.GetChildCount(); i<count; i++)
 305     {
 306       Actor actor = mLayer.GetChildAt(i);
 307       if( actor != mStencilActor )
 308       {
 309         anim.RotateTo( actor, mFinalActorAngle, Vector3::ZAXIS, mEasingFunction, offsetTime, duration );
 310       }
 311     }
 312   }
 313
 314
 315   if( startAnimation )
 316   {
 317     anim.SetLooping(true);
 318     anim.Play();
 319   }
 320 }
 321
 322
 323 void RadialSweepViewImpl::Deactivate()
 324 {
 325   if( mAnim )
 326   {
 327     mAnim.Stop();
 328   }
 329   // mLayer.Remove( mStencilActor );
 330   // mStencilActor.Reset();
 331   // mMesh.Reset();
 332   // mMaterial.Reset();
 333 }
 334
 335 void RadialSweepViewImpl::CreateStencil( Degree initialSector )
 336 {
 337   mMaterial = Material::New("Material");
 338   mMaterial.SetDiffuseColor(Color::WHITE);
 339   mMaterial.SetAmbientColor(Vector4(0.0, 0.1, 0.1, 1.0));
 340
 341   // Generate a square mesh with a point at the center:
 342
 343   AnimatableMesh::Faces faces;
 344   // Create triangles joining up the verts
 345   faces.push_back(0); faces.push_back(1); faces.push_back(2);
 346   faces.push_back(0); faces.push_back(2); faces.push_back(3);
 347   faces.push_back(0); faces.push_back(3); faces.push_back(4);
 348   faces.push_back(0); faces.push_back(4); faces.push_back(5);
 349   faces.push_back(0); faces.push_back(5); faces.push_back(6);
 350
 351   mMesh = AnimatableMesh::New(7, faces, mMaterial);
 352   mMesh[0].SetPosition( Vector3(  0.0f,  0.0f, 0.0f ) ); // Center pt
 353
 354   mStencilActor = MeshActor::New(mMesh);
 355   mStencilActor.SetAffectedByLighting(false);
 356   mStencilActor.SetCullFace(CullNone); // Allow clockwise & anticlockwise faces
 357
 358   mStartAngleIndex = mStencilActor.RegisterProperty("start-angle", Property::Value(0.0f));
 359   mRotationAngleIndex = mStencilActor.RegisterProperty("rotation-angle", Property::Value(initialSector));
 360
 361   Source srcStart( mStencilActor, mStartAngleIndex );
 362   Source srcRot( mStencilActor, mRotationAngleIndex );
 363
 364   // Constrain the vertices of the square mesh to sweep out a sector as the
 365   // rotation angle is animated.
 366   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(1, AnimatableVertex::POSITION),
 367                                                   srcStart, srcStart, SquareFanConstraint(0)));
 368   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(2, AnimatableVertex::POSITION),
 369                                                   srcStart, srcRot, SquareFanConstraint(0)));
 370   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(3, AnimatableVertex::POSITION),
 371                                                   srcStart, srcRot, SquareFanConstraint(1)));
 372   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(4, AnimatableVertex::POSITION),
 373                                                   srcStart, srcRot, SquareFanConstraint(2)));
 374   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(5, AnimatableVertex::POSITION),
 375                                                   srcStart, srcRot, SquareFanConstraint(3)));
 376   mMesh.ApplyConstraint(Constraint::New<Vector3>( mMesh.GetPropertyIndex(6, AnimatableVertex::POSITION),
 377                                                   srcStart, srcRot, SquareFanConstraint(4)));
 378
 379   mStencilActor.SetDrawMode( DrawMode::STENCIL );
 380   mStencilActor.SetPositionInheritanceMode(USE_PARENT_POSITION);
 381 }