automated-tests/src/dali/dali-test-suite-utils/test-dynamics.h

   1 #ifndef __TEST_DYNAMICS_H__
   2 #define __TEST_DYNAMICS_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 #include <dali/integration-api/dynamics/dynamics-body-intf.h>
  22 #include <dali/integration-api/dynamics/dynamics-body-settings.h>
  23 #include <dali/integration-api/dynamics/dynamics-joint-intf.h>
  24 #include <dali/integration-api/dynamics/dynamics-shape-intf.h>
  25 #include <dali/integration-api/dynamics/dynamics-world-intf.h>
  26 #include <dali/integration-api/dynamics/dynamics-world-settings.h>
  27 #include <dali/integration-api/dynamics/dynamics-factory-intf.h>
  28
  29 #include <test-trace-call-stack.h>
  30
  31 namespace Dali
  32 {
  33
  34 class TestDynamicsJoint : public Integration::DynamicsJoint
  35 {
  36 public:
  37   TestDynamicsJoint( TraceCallStack& trace );
  38   virtual ~TestDynamicsJoint();
  39
  40 public: // From Dali::Integration::DynamicsJoint
  41
  42   void Initialize( Integration::DynamicsBody* bodyA, const Vector3& positionA, const Quaternion& rotationA, const Vector3& offsetA,
  43                    Integration::DynamicsBody* bodyB, const Vector3& positionB, const Quaternion& rotationB, const Vector3& offsetB );
  44   void SetLimit( const int axisIndex, const float lowerLimit, const float upperLimit );
  45   void EnableSpring( int axisIndex, bool flag );
  46   void SetSpringStiffness( int axisIndex, float stiffness );
  47   void SetSpringDamping( int axisIndex, float damping );
  48   void SetSpringCenterPoint( int axisIndex, float ratio );
  49   void EnableMotor( int axisIndex, bool flag );
  50   void SetMotorVelocity( int axisIndex, float velocity );
  51   void SetMotorForce( int axisIndex, float force );
  52
  53 private:
  54
  55   TraceCallStack& mTrace;
  56
  57 }; // class TestDynamicsJoint
  58
  59 class TestDynamicsShape : public Integration::DynamicsShape
  60 {
  61 public:
  62
  63   TestDynamicsShape( TraceCallStack& trace );
  64   virtual ~TestDynamicsShape();
  65
  66 public:
  67   void Initialize( int type, const Vector3& dimensions );
  68   void Initialize( int type, Geometry geometry );
  69
  70 private:
  71
  72   TraceCallStack& mTrace;
  73
  74 }; // class TestDynamicsShape
  75
  76 class TestDynamicsBody : public Integration::DynamicsBody
  77 {
  78 public:
  79   TestDynamicsBody( TraceCallStack& trace );
  80
  81   virtual ~TestDynamicsBody();
  82
  83 public: // From Dali::Integration::DynamicsBody
  84
  85   inline void Initialize( const Integration::DynamicsBodySettings& bodySettings, Integration::DynamicsShape* shape,
  86                    Integration::DynamicsWorld& dynamicsWorld,
  87                    const Vector3& startPosition, const Quaternion& startRotation )
  88   {
  89     mTrace.PushCall( "DynamicsBody::~DynamicsBody", "" );
  90   }
  91
  92   inline void SetMass( float mass )
  93   {
  94     mTrace.PushCall( "DynamicsBody::SetMass", "" );
  95   }
  96
  97   inline void SetElasticity( float elasticity )
  98   {
  99     mTrace.PushCall( "DynamicsBody::SetElasticity", "" );
 100   }
 101
 102   inline void SetLinearVelocity( const Vector3& velocity )
 103   {
 104     mTrace.PushCall( "DynamicsBody::SetLinearVelocity", "" );
 105   }
 106
 107   inline Vector3 GetLinearVelocity() const
 108   {
 109     mTrace.PushCall( "DynamicsBody::GetLinearVelocity", "" );
 110     return Vector3::ZERO;
 111   }
 112
 113   inline void SetAngularVelocity( const Vector3& velocity )
 114   {
 115     mTrace.PushCall( "DynamicsBody::SetAngularVelocity", "" );
 116   }
 117
 118   inline Vector3 GetAngularVelocity() const
 119   {
 120     mTrace.PushCall( "DynamicsBody::GetAngularVelocity", "" );
 121     return Vector3::ZERO;
 122   }
 123
 124   inline void SetKinematic( bool flag )
 125   {
 126     mTrace.PushCall( "DynamicsBody::SetKinematic", "" );
 127   }
 128
 129   inline bool IsKinematic() const
 130   {
 131     mTrace.PushCall( "DynamicsBody::IsKinematic", "" );
 132     return mKinematic;
 133   }
 134
 135   inline void SetSleepEnabled( bool flag )
 136   {
 137     mTrace.PushCall( "DynamicsBody::SetSleepEnabled", "" );
 138   }
 139
 140   inline void WakeUp()
 141   {
 142     mTrace.PushCall( "DynamicsBody::WakeUp", "" );
 143   }
 144
 145   inline void AddAnchor( unsigned int index, const Integration::DynamicsBody* anchorBody, bool collisions )
 146   {
 147     mTrace.PushCall( "DynamicsBody::AddAnchor", "" );
 148   }
 149
 150   inline void ConserveVolume( bool flag )
 151   {
 152     mTrace.PushCall( "DynamicsBody::ConserveVolume", "" );
 153   }
 154
 155   inline void ConserveShape( bool flag )
 156   {
 157     mTrace.PushCall( "DynamicsBody::ConserveShape", "" );
 158   }
 159
 160   inline short int GetCollisionGroup() const
 161   {
 162     mTrace.PushCall( "DynamicsBody::GetCollisionGroup", "" );
 163     return mCollisionGroup;
 164   }
 165
 166   inline void SetCollisionGroup( short int collisionGroup )
 167   {
 168     mTrace.PushCall( "DynamicsBody::SetCollisionGroup", "" );
 169     mCollisionGroup = collisionGroup;
 170   }
 171
 172   inline short int GetCollisionMask() const
 173   {
 174     mTrace.PushCall( "DynamicsBody::GetCollisionMask", "" );
 175     return mCollisionMask;
 176   }
 177
 178   inline void SetCollisionMask( short int collisionMask )
 179   {
 180     mTrace.PushCall( "DynamicsBody::SetCollisionMask", "" );
 181     mCollisionMask = collisionMask;
 182   }
 183
 184   inline int GetType() const
 185   {
 186     mTrace.PushCall( "DynamicsBody::GetType", "" );
 187     return mSettings->type;
 188   }
 189
 190   inline bool IsActive() const
 191   {
 192     mTrace.PushCall( "DynamicsBody::IsActive", "" );
 193     return mActivationState;
 194   }
 195
 196   inline void SetTransform( const Vector3& position, const Quaternion& rotation )
 197   {
 198     mTrace.PushCall( "DynamicsBody::SetTransform", "" );
 199   }
 200
 201   inline void GetTransform( Vector3& position, Quaternion& rotation )
 202   {
 203     mTrace.PushCall( "DynamicsBody::GetTransform", "" );
 204   }
 205
 206   inline void GetSoftVertices( Geometry geometry ) const
 207   {
 208     mTrace.PushCall( "DynamicsBody::GetSoftVertices", "" );
 209   }
 210
 211 private:
 212   Dali::Integration::DynamicsBodySettings* mSettings;
 213   bool mConserveVolume:1;
 214   bool mConserveShape:1;
 215   bool mKinematic:1;
 216   bool mActivationState:1;
 217
 218   short int mCollisionGroup;
 219   short int mCollisionMask;
 220
 221   TraceCallStack& mTrace;
 222 }; // class TestDynamicsBody
 223
 224 class TestDynamicsWorld : public Dali::Integration::DynamicsWorld
 225 {
 226 public:
 227
 228   TestDynamicsWorld( TraceCallStack& trace );
 229
 230   virtual ~TestDynamicsWorld();
 231
 232   inline void Initialize( const Dali::Integration::DynamicsWorldSettings& worldSettings )
 233   {
 234
 235     mTrace.PushCall( "DynamicsWorld::Initialize", "" );
 236   }
 237
 238   inline void AddBody( Dali::Integration::DynamicsBody* body )
 239   {
 240     mTrace.PushCall( "DynamicsWorld::AddBody", "" );
 241   }
 242
 243   inline void RemoveBody( Dali::Integration::DynamicsBody* body )
 244   {
 245     mTrace.PushCall( "DynamicsWorld::RemoveBody", "" );
 246   }
 247
 248   inline void AddJoint( Dali::Integration::DynamicsJoint* joint )
 249   {
 250     mTrace.PushCall( "DynamicsWorld::AddJoint", "" );
 251   }
 252
 253   inline void RemoveJoint( Dali::Integration::DynamicsJoint* joint )
 254   {
 255     mTrace.PushCall( "DynamicsWorld::RemoveJoint", "" );
 256   }
 257
 258   inline void SetGravity( const Vector3& gravity )
 259   {
 260     mTrace.PushCall( "DynamicsWorld::SetGravity", "" );
 261   }
 262
 263   inline void SetDebugDrawMode(int mode)
 264   {
 265     mTrace.PushCall( "DynamicsWorld::SetDebugDrawMode", "" );
 266   }
 267
 268   inline const Integration::DynamicsDebugVertexContainer& DebugDraw()
 269   {
 270     mTrace.PushCall( "DynamicsWorld::DebugDraw", "" );
 271     return mDebugVertices;
 272   }
 273
 274   inline void Update( float elapsedSeconds )
 275   {
 276     mTrace.PushCall( "DynamicsWorld::Update", "" );
 277   }
 278
 279   inline void CheckForCollisions( Integration::CollisionDataContainer& contacts )
 280   {
 281     mTrace.PushCall( "DynamicsWorld::CheckForCollisions", "" );
 282   }
 283
 284 private:
 285   Dali::Integration::DynamicsWorldSettings* mSettings;
 286   Dali::Integration::DynamicsDebugVertexContainer mDebugVertices;
 287
 288   TraceCallStack& mTrace;
 289
 290 }; // class TestDynamicsWorld
 291
 292 class TestDynamicsFactory : public Integration::DynamicsFactory
 293 {
 294
 295 public:
 296
 297   TestDynamicsFactory( TraceCallStack& trace );
 298
 299   virtual ~TestDynamicsFactory();
 300
 301   virtual bool InitializeDynamics( const Integration::DynamicsWorldSettings& worldSettings );
 302
 303   virtual void TerminateDynamics();
 304
 305   virtual Integration::DynamicsWorld* CreateDynamicsWorld();
 306   virtual Integration::DynamicsBody* CreateDynamicsBody();
 307
 308   virtual Integration::DynamicsJoint* CreateDynamicsJoint();
 309
 310   virtual Integration::DynamicsShape* CreateDynamicsShape();
 311
 312   TraceCallStack& mTrace;
 313 }; // class TestDynamicsFactory
 314
 315 } // Dali
 316
 317 #endif // __TEST_DYNAMICS_H__