iPhoneTest.h
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:5k
源码类别:

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
  3. *
  4. * iPhone port by Simon Oliver - http://www.simonoliver.com - http://www.handcircus.com
  5. *
  6. * This software is provided 'as-is', without any express or implied
  7. * warranty.  In no event will the authors be held liable for any damages
  8. * arising from the use of this software.
  9. * Permission is granted to anyone to use this software for any purpose,
  10. * including commercial applications, and to alter it and redistribute it
  11. * freely, subject to the following restrictions:
  12. * 1. The origin of this software must not be misrepresented; you must not
  13. * claim that you wrote the original software. If you use this software
  14. * in a product, an acknowledgment in the product documentation would be
  15. * appreciated but is not required.
  16. * 2. Altered source versions must be plainly marked as such, and must not be
  17. * misrepresented as being the original software.
  18. * 3. This notice may not be removed or altered from any source distribution.
  19. */
  20. #ifndef TEST_H
  21. #define TEST_H
  22. #import <UIKit/UIKit.h>
  23. #include <Box2D/Box2D.h>
  24. #include "GLES-Render.h"
  25. #include <cstdlib>
  26. class Test;
  27. struct Settings;
  28. typedef Test* TestCreateFcn();
  29. #define RAND_LIMIT 32767
  30. /// Random number in range [-1,1]
  31. inline float32 RandomFloat()
  32. {
  33. float32 r = (float32)(rand() & (RAND_LIMIT));
  34. r /= RAND_LIMIT;
  35. r = 2.0f * r - 1.0f;
  36. return r;
  37. }
  38. /// Random floating point number in range [lo, hi]
  39. inline float32 RandomFloat(float32 lo, float32 hi)
  40. {
  41. float32 r = (float32)(rand() & (RAND_LIMIT));
  42. r /= RAND_LIMIT;
  43. r = (hi - lo) * r + lo;
  44. return r;
  45. }
  46. /// Test settings. Some can be controlled in the GUI.
  47. struct Settings
  48. {
  49. Settings() :
  50. hz(60.0f),
  51. velocityIterations(10),
  52. positionIterations(4),
  53. drawStats(0),
  54. drawShapes(1),
  55. drawJoints(1),
  56. drawAABBs(0),
  57. drawPairs(0),
  58. drawContactPoints(0),
  59. drawContactNormals(0),
  60. drawContactForces(0),
  61. drawFrictionForces(0),
  62. drawCOMs(0),
  63. enableWarmStarting(1),
  64. enableContinuous(1),
  65. pause(0),
  66. singleStep(0)
  67. {}
  68. float32 hz;
  69. int32 velocityIterations;
  70. int32 positionIterations;
  71. int32 drawShapes;
  72. int32 drawJoints;
  73. int32 drawAABBs;
  74. int32 drawPairs;
  75. int32 drawContactPoints;
  76. int32 drawContactNormals;
  77. int32 drawContactForces;
  78. int32 drawFrictionForces;
  79. int32 drawCOMs;
  80. int32 drawStats;
  81. int32 enableWarmStarting;
  82. int32 enableContinuous;
  83. int32 pause;
  84. int32 singleStep;
  85. };
  86. struct TestEntry
  87. {
  88. const char *name;
  89. TestCreateFcn *createFcn;
  90. };
  91. extern TestEntry g_testEntries[];
  92. // This is called when a joint in the world is implicitly destroyed
  93. // because an attached body is destroyed. This gives us a chance to
  94. // nullify the mouse joint.
  95. class DestructionListener : public b2DestructionListener
  96. {
  97. public:
  98. void SayGoodbye(b2Fixture* fixture) { B2_NOT_USED(fixture); }
  99. void SayGoodbye(b2Joint* joint);
  100. Test* test;
  101. };
  102. const int32 k_maxContactPoints = 2048;
  103. struct ContactPoint
  104. {
  105. b2Fixture* fixtureA;
  106. b2Fixture* fixtureB;
  107. b2Vec2 normal;
  108. b2Vec2 position;
  109. b2PointState state;
  110. };
  111. class Test : public b2ContactListener
  112. {
  113. public:
  114. Test();
  115. virtual ~Test();
  116. void SetGravity(float x,float y);
  117. void SetTextLine(int32 line) { m_textLine = line; }
  118. void DrawTitle(int x, int y, const char *string);
  119. virtual void Step(Settings* settings);
  120. virtual void Keyboard(unsigned char key) { B2_NOT_USED(key); }
  121. void ShiftMouseDown(const b2Vec2& p);
  122. virtual void MouseDown(const b2Vec2& p);
  123. virtual void MouseUp(const b2Vec2& p);
  124. void MouseMove(const b2Vec2& p);
  125. void LaunchBomb();
  126. void LaunchBomb(const b2Vec2& position, const b2Vec2& velocity);
  127. void SpawnBomb(const b2Vec2& worldPt);
  128. void CompleteBombSpawn(const b2Vec2& p);
  129. // Let derived tests know that a joint was destroyed.
  130. virtual void JointDestroyed(b2Joint* joint) { B2_NOT_USED(joint); }
  131. // Callbacks for derived classes.
  132. virtual void BeginContact(b2Contact* contact) { B2_NOT_USED(contact); }
  133. virtual void EndContact(b2Contact* contact) { B2_NOT_USED(contact); }
  134. virtual void PreSolve(b2Contact* contact, const b2Manifold* oldManifold);
  135. virtual void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse)
  136. {
  137. B2_NOT_USED(contact);
  138. B2_NOT_USED(impulse);
  139. }
  140. protected:
  141. friend class DestructionListener;
  142. friend class BoundaryListener;
  143. friend class ContactListener;
  144. b2Body* m_groundBody;
  145. b2AABB m_worldAABB;
  146. ContactPoint m_points[k_maxContactPoints];
  147. int32 m_pointCount;
  148. DestructionListener m_destructionListener;
  149. GLESDebugDraw m_debugDraw;
  150. int32 m_textLine;
  151. b2World* m_world;
  152. b2Body* m_bomb;
  153. b2MouseJoint* m_mouseJoint;
  154. b2Vec2 m_bombSpawnPoint;
  155. bool m_bombSpawning;
  156. b2Vec2 m_mouseWorld;
  157. int32 m_stepCount;
  158. };
  159. #endif