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

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2009 Erin Catto http://www.gphysics.com
  3. *
  4. * This software is provided 'as-is', without any express or implied
  5. * warranty.  In no event will the authors be held liable for any damages
  6. * arising from the use of this software.
  7. * Permission is granted to anyone to use this software for any purpose,
  8. * including commercial applications, and to alter it and redistribute it
  9. * freely, subject to the following restrictions:
  10. * 1. The origin of this software must not be misrepresented; you must not
  11. * claim that you wrote the original software. If you use this software
  12. * in a product, an acknowledgment in the product documentation would be
  13. * appreciated but is not required.
  14. * 2. Altered source versions must be plainly marked as such, and must not be
  15. * misrepresented as being the original software.
  16. * 3. This notice may not be removed or altered from any source distribution.
  17. */
  18. #ifndef RAY_CAST_H
  19. #define RAY_CAST_H
  20. // This test demonstrates how to use the world ray-cast feature.
  21. // NOTE: we are intentionally filtering one of the polygons, therefore
  22. // the ray will always miss one type of polygon.
  23. // This callback finds the closest hit. Polygon 0 is filtered.
  24. class RayCastClosestCallback : public b2RayCastCallback
  25. {
  26. public:
  27. RayCastClosestCallback()
  28. {
  29. m_hit = false;
  30. }
  31. float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
  32. const b2Vec2& normal, float32 fraction)
  33. {
  34. b2Body* body = fixture->GetBody();
  35. void* userData = body->GetUserData();
  36. if (userData)
  37. {
  38. int32 index = *(int32*)userData;
  39. if (index == 0)
  40. {
  41. // filter
  42. return -1.0f;
  43. }
  44. }
  45. m_hit = true;
  46. m_point = point;
  47. m_normal = normal;
  48. return fraction;
  49. }
  50. bool m_hit;
  51. b2Vec2 m_point;
  52. b2Vec2 m_normal;
  53. };
  54. // This callback finds any hit. Polygon 0 is filtered.
  55. class RayCastAnyCallback : public b2RayCastCallback
  56. {
  57. public:
  58. RayCastAnyCallback()
  59. {
  60. m_hit = false;
  61. }
  62. float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
  63. const b2Vec2& normal, float32 fraction)
  64. {
  65. b2Body* body = fixture->GetBody();
  66. void* userData = body->GetUserData();
  67. if (userData)
  68. {
  69. int32 index = *(int32*)userData;
  70. if (index == 0)
  71. {
  72. // filter
  73. return -1.0f;
  74. }
  75. }
  76. m_hit = true;
  77. m_point = point;
  78. m_normal = normal;
  79. return 0.0f;
  80. }
  81. bool m_hit;
  82. b2Vec2 m_point;
  83. b2Vec2 m_normal;
  84. };
  85. // This ray cast collects multiple hits along the ray. Polygon 0 is filtered.
  86. class RayCastMultipleCallback : public b2RayCastCallback
  87. {
  88. public:
  89. enum
  90. {
  91. e_maxCount = 3
  92. };
  93. RayCastMultipleCallback()
  94. {
  95. m_count = 0;
  96. }
  97. float32 ReportFixture( b2Fixture* fixture, const b2Vec2& point,
  98. const b2Vec2& normal, float32 fraction)
  99. {
  100. b2Body* body = fixture->GetBody();
  101. int32 index = 0;
  102. void* userData = body->GetUserData();
  103. if (userData)
  104. {
  105. int32 index = *(int32*)userData;
  106. if (index == 0)
  107. {
  108. // filter
  109. return -1.0f;
  110. }
  111. }
  112. b2Assert(m_count < e_maxCount);
  113. m_points[m_count] = point;
  114. m_normals[m_count] = normal;
  115. ++m_count;
  116. if (m_count == e_maxCount)
  117. {
  118. return 0.0f;
  119. }
  120. return 1.0f;
  121. }
  122. b2Vec2 m_points[e_maxCount];
  123. b2Vec2 m_normals[e_maxCount];
  124. int32 m_count;
  125. };
  126. class RayCast : public Test
  127. {
  128. public:
  129. enum
  130. {
  131. e_maxBodies = 256,
  132. };
  133. enum Mode
  134. {
  135. e_closest,
  136. e_any,
  137. e_multiple
  138. };
  139. RayCast()
  140. {
  141. // Ground body
  142. {
  143. b2BodyDef bd;
  144. b2Body* ground = m_world->CreateBody(&bd);
  145. b2PolygonShape shape;
  146. shape.SetAsEdge(b2Vec2(-40.0f, 0.0f), b2Vec2(40.0f, 0.0f));
  147. ground->CreateFixture(&shape, 0.0f);
  148. }
  149. {
  150. b2Vec2 vertices[3];
  151. vertices[0].Set(-0.5f, 0.0f);
  152. vertices[1].Set(0.5f, 0.0f);
  153. vertices[2].Set(0.0f, 1.5f);
  154. m_polygons[0].Set(vertices, 3);
  155. }
  156. {
  157. b2Vec2 vertices[3];
  158. vertices[0].Set(-0.1f, 0.0f);
  159. vertices[1].Set(0.1f, 0.0f);
  160. vertices[2].Set(0.0f, 1.5f);
  161. m_polygons[1].Set(vertices, 3);
  162. }
  163. {
  164. float32 w = 1.0f;
  165. float32 b = w / (2.0f + sqrtf(2.0f));
  166. float32 s = sqrtf(2.0f) * b;
  167. b2Vec2 vertices[8];
  168. vertices[0].Set(0.5f * s, 0.0f);
  169. vertices[1].Set(0.5f * w, b);
  170. vertices[2].Set(0.5f * w, b + s);
  171. vertices[3].Set(0.5f * s, w);
  172. vertices[4].Set(-0.5f * s, w);
  173. vertices[5].Set(-0.5f * w, b + s);
  174. vertices[6].Set(-0.5f * w, b);
  175. vertices[7].Set(-0.5f * s, 0.0f);
  176. m_polygons[2].Set(vertices, 8);
  177. }
  178. {
  179. m_polygons[3].SetAsBox(0.5f, 0.5f);
  180. }
  181. {
  182. m_circle.m_radius = 0.5f;
  183. }
  184. m_bodyIndex = 0;
  185. memset(m_bodies, 0, sizeof(m_bodies));
  186. m_angle = 0.0f;
  187. m_mode = e_closest;
  188. }
  189. void Create(int32 index)
  190. {
  191. if (m_bodies[m_bodyIndex] != NULL)
  192. {
  193. m_world->DestroyBody(m_bodies[m_bodyIndex]);
  194. m_bodies[m_bodyIndex] = NULL;
  195. }
  196. b2BodyDef bd;
  197. float32 x = RandomFloat(-10.0f, 10.0f);
  198. float32 y = RandomFloat(0.0f, 20.0f);
  199. bd.position.Set(x, y);
  200. bd.angle = RandomFloat(-b2_pi, b2_pi);
  201. m_userData[m_bodyIndex] = index;
  202. bd.userData = m_userData + m_bodyIndex;
  203. if (index == 4)
  204. {
  205. bd.angularDamping = 0.02f;
  206. }
  207. m_bodies[m_bodyIndex] = m_world->CreateBody(&bd);
  208. if (index < 4)
  209. {
  210. b2FixtureDef fd;
  211. fd.shape = m_polygons + index;
  212. fd.friction = 0.3f;
  213. m_bodies[m_bodyIndex]->CreateFixture(&fd);
  214. }
  215. else
  216. {
  217. b2FixtureDef fd;
  218. fd.shape = &m_circle;
  219. fd.friction = 0.3f;
  220. m_bodies[m_bodyIndex]->CreateFixture(&fd);
  221. }
  222. m_bodyIndex = (m_bodyIndex + 1) % e_maxBodies;
  223. }
  224. void DestroyBody()
  225. {
  226. for (int32 i = 0; i < e_maxBodies; ++i)
  227. {
  228. if (m_bodies[i] != NULL)
  229. {
  230. m_world->DestroyBody(m_bodies[i]);
  231. m_bodies[i] = NULL;
  232. return;
  233. }
  234. }
  235. }
  236. void Keyboard(unsigned char key)
  237. {
  238. switch (key)
  239. {
  240. case '1':
  241. case '2':
  242. case '3':
  243. case '4':
  244. case '5':
  245. Create(key - '1');
  246. break;
  247. case 'd':
  248. DestroyBody();
  249. break;
  250. case 'm':
  251. if (m_mode == e_closest)
  252. {
  253. m_mode = e_any;
  254. }
  255. else if (m_mode == e_any)
  256. {
  257. m_mode = e_multiple;
  258. }
  259. else if (m_mode = e_multiple)
  260. {
  261. m_mode = e_closest;
  262. }
  263. }
  264. }
  265. void Step(Settings* settings)
  266. {
  267. bool advanceRay = settings->pause == 0 || settings->singleStep;
  268. Test::Step(settings);
  269. m_debugDraw.DrawString(5, m_textLine, "Press 1-5 to drop stuff, m to change the mode");
  270. m_textLine += 15;
  271. m_debugDraw.DrawString(5, m_textLine, "Mode = %d", m_mode);
  272. m_textLine += 15;
  273. float32 L = 11.0f;
  274. b2Vec2 point1(0.0f, 10.0f);
  275. b2Vec2 d(L * cosf(m_angle), L * sinf(m_angle));
  276. b2Vec2 point2 = point1 + d;
  277. if (m_mode == e_closest)
  278. {
  279. RayCastClosestCallback callback;
  280. m_world->RayCast(&callback, point1, point2);
  281. if (callback.m_hit)
  282. {
  283. m_debugDraw.DrawPoint(callback.m_point, 5.0f, b2Color(0.4f, 0.9f, 0.4f));
  284. m_debugDraw.DrawSegment(point1, callback.m_point, b2Color(0.8f, 0.8f, 0.8f));
  285. b2Vec2 head = callback.m_point + 0.5f * callback.m_normal;
  286. m_debugDraw.DrawSegment(callback.m_point, head, b2Color(0.9f, 0.9f, 0.4f));
  287. }
  288. else
  289. {
  290. m_debugDraw.DrawSegment(point1, point2, b2Color(0.8f, 0.8f, 0.8f));
  291. }
  292. }
  293. else if (m_mode == e_any)
  294. {
  295. RayCastAnyCallback callback;
  296. m_world->RayCast(&callback, point1, point2);
  297. if (callback.m_hit)
  298. {
  299. m_debugDraw.DrawPoint(callback.m_point, 5.0f, b2Color(0.4f, 0.9f, 0.4f));
  300. m_debugDraw.DrawSegment(point1, callback.m_point, b2Color(0.8f, 0.8f, 0.8f));
  301. b2Vec2 head = callback.m_point + 0.5f * callback.m_normal;
  302. m_debugDraw.DrawSegment(callback.m_point, head, b2Color(0.9f, 0.9f, 0.4f));
  303. }
  304. else
  305. {
  306. m_debugDraw.DrawSegment(point1, point2, b2Color(0.8f, 0.8f, 0.8f));
  307. }
  308. }
  309. else if (m_mode == e_multiple)
  310. {
  311. RayCastMultipleCallback callback;
  312. m_world->RayCast(&callback, point1, point2);
  313. m_debugDraw.DrawSegment(point1, point2, b2Color(0.8f, 0.8f, 0.8f));
  314. for (int32 i = 0; i < callback.m_count; ++i)
  315. {
  316. b2Vec2 p = callback.m_points[i];
  317. b2Vec2 n = callback.m_normals[i];
  318. m_debugDraw.DrawPoint(p, 5.0f, b2Color(0.4f, 0.9f, 0.4f));
  319. m_debugDraw.DrawSegment(point1, p, b2Color(0.8f, 0.8f, 0.8f));
  320. b2Vec2 head = p + 0.5f * n;
  321. m_debugDraw.DrawSegment(p, head, b2Color(0.9f, 0.9f, 0.4f));
  322. }
  323. }
  324. if (advanceRay)
  325. {
  326. m_angle += 0.25f * b2_pi / 180.0f;
  327. }
  328. #if 0
  329. // This case was failing.
  330. {
  331. b2Vec2 vertices[4];
  332. //vertices[0].Set(-22.875f, -3.0f);
  333. //vertices[1].Set(22.875f, -3.0f);
  334. //vertices[2].Set(22.875f, 3.0f);
  335. //vertices[3].Set(-22.875f, 3.0f);
  336. b2PolygonShape shape;
  337. //shape.Set(vertices, 4);
  338. shape.SetAsBox(22.875f, 3.0f);
  339. b2RayCastInput input;
  340. input.p1.Set(10.2725f,1.71372f);
  341. input.p2.Set(10.2353f,2.21807f);
  342. //input.maxFraction = 0.567623f;
  343. input.maxFraction = 0.56762173f;
  344. b2Transform xf;
  345. xf.SetIdentity();
  346. xf.position.Set(23.0f, 5.0f);
  347. b2RayCastOutput output;
  348. bool hit;
  349. hit = shape.RayCast(&output, input, xf);
  350. hit = false;
  351. b2Color color(1.0f, 1.0f, 1.0f);
  352. b2Vec2 vs[4];
  353. for (int32 i = 0; i < 4; ++i)
  354. {
  355. vs[i] = b2Mul(xf, shape.m_vertices[i]);
  356. }
  357. m_debugDraw.DrawPolygon(vs, 4, color);
  358. m_debugDraw.DrawSegment(input.p1, input.p2, color);
  359. }
  360. #endif
  361. }
  362. static Test* Create()
  363. {
  364. return new RayCast;
  365. }
  366. int32 m_bodyIndex;
  367. b2Body* m_bodies[e_maxBodies];
  368. int32 m_userData[e_maxBodies];
  369. b2PolygonShape m_polygons[4];
  370. b2CircleShape m_circle;
  371. float32 m_angle;
  372. Mode m_mode;
  373. };
  374. #endif