automated-tests/src/dali-unmanaged/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
  69   void Initialize( int type, const MeshData::VertexContainer& vertices, const MeshData::FaceIndices& faceIndices );
  70
  71 public:
  72
  73   MeshData::VertexContainer* mVertices;
  74   MeshData::FaceIndices*     mFaces;
  75
  76 private:
  77
  78   TraceCallStack& mTrace;
  79
  80 }; // class TestDynamicsShape
  81
  82 class TestDynamicsBody : public Integration::DynamicsBody
  83 {
  84 public:
  85   TestDynamicsBody( TraceCallStack& trace );
  86
  87   virtual ~TestDynamicsBody();
  88
  89 public: // From Dali::Integration::DynamicsBody
  90
  91   inline void Initialize( const Integration::DynamicsBodySettings& bodySettings, Integration::DynamicsShape* shape,
  92                    Integration::DynamicsWorld& dynamicsWorld,
  93                    const Vector3& startPosition, const Quaternion& startRotation )
  94   {
  95     mTrace.PushCall( "DynamicsBody::~DynamicsBody", "" );
  96   }
  97
  98   inline void SetMass( float mass )
  99   {
 100     mTrace.PushCall( "DynamicsBody::SetMass", "" );
 101   }
 102
 103   inline void SetElasticity( float elasticity )
 104   {
 105     mTrace.PushCall( "DynamicsBody::SetElasticity", "" );
 106   }
 107
 108   inline void SetLinearVelocity( const Vector3& velocity )
 109   {
 110     mTrace.PushCall( "DynamicsBody::SetLinearVelocity", "" );
 111   }
 112
 113   inline Vector3 GetLinearVelocity() const
 114   {
 115     mTrace.PushCall( "DynamicsBody::GetLinearVelocity", "" );
 116     return Vector3::ZERO;
 117   }
 118
 119   inline void SetAngularVelocity( const Vector3& velocity )
 120   {
 121     mTrace.PushCall( "DynamicsBody::SetAngularVelocity", "" );
 122   }
 123
 124   inline Vector3 GetAngularVelocity() const
 125   {
 126     mTrace.PushCall( "DynamicsBody::GetAngularVelocity", "" );
 127     return Vector3::ZERO;
 128   }
 129
 130   inline void SetKinematic( bool flag )
 131   {
 132     mTrace.PushCall( "DynamicsBody::SetKinematic", "" );
 133   }
 134
 135   inline bool IsKinematic() const
 136   {
 137     mTrace.PushCall( "DynamicsBody::IsKinematic", "" );
 138     return mKinematic;
 139   }
 140
 141   inline void SetSleepEnabled( bool flag )
 142   {
 143     mTrace.PushCall( "DynamicsBody::SetSleepEnabled", "" );
 144   }
 145
 146   inline void WakeUp()
 147   {
 148     mTrace.PushCall( "DynamicsBody::WakeUp", "" );
 149   }
 150
 151   inline void AddAnchor( unsigned int index, const Integration::DynamicsBody* anchorBody, bool collisions )
 152   {
 153     mTrace.PushCall( "DynamicsBody::AddAnchor", "" );
 154   }
 155
 156   inline void ConserveVolume( bool flag )
 157   {
 158     mTrace.PushCall( "DynamicsBody::ConserveVolume", "" );
 159   }
 160
 161   inline void ConserveShape( bool flag )
 162   {
 163     mTrace.PushCall( "DynamicsBody::ConserveShape", "" );
 164   }
 165
 166   inline short int GetCollisionGroup() const
 167   {
 168     mTrace.PushCall( "DynamicsBody::GetCollisionGroup", "" );
 169     return mCollisionGroup;
 170   }
 171
 172   inline void SetCollisionGroup( short int collisionGroup )
 173   {
 174     mTrace.PushCall( "DynamicsBody::SetCollisionGroup", "" );
 175     mCollisionGroup = collisionGroup;
 176   }
 177
 178   inline short int GetCollisionMask() const
 179   {
 180     mTrace.PushCall( "DynamicsBody::GetCollisionMask", "" );
 181     return mCollisionMask;
 182   }
 183
 184   inline void SetCollisionMask( short int collisionMask )
 185   {
 186     mTrace.PushCall( "DynamicsBody::SetCollisionMask", "" );
 187     mCollisionMask = collisionMask;
 188   }
 189
 190   inline int GetType() const
 191   {
 192     mTrace.PushCall( "DynamicsBody::GetType", "" );
 193     return mSettings->type;
 194   }
 195
 196   inline bool IsActive() const
 197   {
 198     mTrace.PushCall( "DynamicsBody::IsActive", "" );
 199     return mActivationState;
 200   }
 201
 202   inline void SetTransform( const Vector3& position, const Quaternion& rotation )
 203   {
 204     mTrace.PushCall( "DynamicsBody::SetTransform", "" );
 205   }
 206
 207   inline void GetTransform( Vector3& position, Quaternion& rotation )
 208   {
 209     mTrace.PushCall( "DynamicsBody::GetTransform", "" );
 210   }
 211
 212   inline void GetSoftVertices( MeshData::VertexContainer& vertices ) const
 213   {
 214     mTrace.PushCall( "DynamicsBody::GetSoftVertices", "" );
 215   }
 216
 217 private:
 218   Dali::Integration::DynamicsBodySettings* mSettings;
 219   bool mConserveVolume:1;
 220   bool mConserveShape:1;
 221   bool mKinematic:1;
 222   bool mActivationState:1;
 223
 224   short int mCollisionGroup;
 225   short int mCollisionMask;
 226
 227   TraceCallStack& mTrace;
 228 }; // class TestDynamicsBody
 229
 230 class TestDynamicsWorld : public Dali::Integration::DynamicsWorld
 231 {
 232 public:
 233
 234   TestDynamicsWorld( TraceCallStack& trace );
 235
 236   virtual ~TestDynamicsWorld();
 237
 238   inline void Initialize( const Dali::Integration::DynamicsWorldSettings& worldSettings )
 239   {
 240
 241     mTrace.PushCall( "DynamicsWorld::Initialize", "" );
 242   }
 243
 244   inline void AddBody( Dali::Integration::DynamicsBody* body )
 245   {
 246     mTrace.PushCall( "DynamicsWorld::AddBody", "" );
 247   }
 248
 249   inline void RemoveBody( Dali::Integration::DynamicsBody* body )
 250   {
 251     mTrace.PushCall( "DynamicsWorld::RemoveBody", "" );
 252   }
 253
 254   inline void AddJoint( Dali::Integration::DynamicsJoint* joint )
 255   {
 256     mTrace.PushCall( "DynamicsWorld::AddJoint", "" );
 257   }
 258
 259   inline void RemoveJoint( Dali::Integration::DynamicsJoint* joint )
 260   {
 261     mTrace.PushCall( "DynamicsWorld::RemoveJoint", "" );
 262   }
 263
 264   inline void SetGravity( const Vector3& gravity )
 265   {
 266     mTrace.PushCall( "DynamicsWorld::SetGravity", "" );
 267   }
 268
 269   inline void SetDebugDrawMode(int mode)
 270   {
 271     mTrace.PushCall( "DynamicsWorld::SetDebugDrawMode", "" );
 272   }
 273
 274   inline const Integration::DynamicsDebugVertexContainer& DebugDraw()
 275   {
 276     mTrace.PushCall( "DynamicsWorld::DebugDraw", "" );
 277     return mDebugVertices;
 278   }
 279
 280   inline void Update( float elapsedSeconds )
 281   {
 282     mTrace.PushCall( "DynamicsWorld::Update", "" );
 283   }
 284
 285   inline void CheckForCollisions( Integration::CollisionDataContainer& contacts )
 286   {
 287     mTrace.PushCall( "DynamicsWorld::CheckForCollisions", "" );
 288   }
 289
 290 private:
 291   Dali::Integration::DynamicsWorldSettings* mSettings;
 292   Dali::Integration::DynamicsDebugVertexContainer mDebugVertices;
 293
 294   TraceCallStack& mTrace;
 295
 296 }; // class TestDynamicsWorld
 297
 298 class TestDynamicsFactory : public Integration::DynamicsFactory
 299 {
 300
 301 public:
 302
 303   TestDynamicsFactory( TraceCallStack& trace );
 304
 305   virtual ~TestDynamicsFactory();
 306
 307   virtual bool InitializeDynamics( const Integration::DynamicsWorldSettings& worldSettings );
 308
 309   virtual void TerminateDynamics();
 310
 311   virtual Integration::DynamicsWorld* CreateDynamicsWorld();
 312   virtual Integration::DynamicsBody* CreateDynamicsBody();
 313
 314   virtual Integration::DynamicsJoint* CreateDynamicsJoint();
 315
 316   virtual Integration::DynamicsShape* CreateDynamicsShape();
 317
 318   TraceCallStack& mTrace;
 319 }; // class TestDynamicsFactory
 320
 321 } // Dali
 322
 323 #endif // __TEST_DYNAMICS_H__