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

游戏引擎

开发平台:

Visual C++

  1. /*
  2. * Copyright (c) 2006-2007 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. #include "Render.h"
  19. #include "freeglut/GL/glut.h"
  20. #include <cstdio>
  21. #include <cstdarg>
  22. #include <cstring>
  23. void DebugDraw::DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
  24. {
  25. glColor3f(color.r, color.g, color.b);
  26. glBegin(GL_LINE_LOOP);
  27. for (int32 i = 0; i < vertexCount; ++i)
  28. {
  29. glVertex2f(vertices[i].x, vertices[i].y);
  30. }
  31. glEnd();
  32. }
  33. void DebugDraw::DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color)
  34. {
  35. glEnable(GL_BLEND);
  36. glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  37. glColor4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
  38. glBegin(GL_TRIANGLE_FAN);
  39. for (int32 i = 0; i < vertexCount; ++i)
  40. {
  41. glVertex2f(vertices[i].x, vertices[i].y);
  42. }
  43. glEnd();
  44. glDisable(GL_BLEND);
  45. glColor4f(color.r, color.g, color.b, 1.0f);
  46. glBegin(GL_LINE_LOOP);
  47. for (int32 i = 0; i < vertexCount; ++i)
  48. {
  49. glVertex2f(vertices[i].x, vertices[i].y);
  50. }
  51. glEnd();
  52. }
  53. void DebugDraw::DrawCircle(const b2Vec2& center, float32 radius, const b2Color& color)
  54. {
  55. const float32 k_segments = 16.0f;
  56. const float32 k_increment = 2.0f * b2_pi / k_segments;
  57. float32 theta = 0.0f;
  58. glColor3f(color.r, color.g, color.b);
  59. glBegin(GL_LINE_LOOP);
  60. for (int32 i = 0; i < k_segments; ++i)
  61. {
  62. b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));
  63. glVertex2f(v.x, v.y);
  64. theta += k_increment;
  65. }
  66. glEnd();
  67. }
  68. void DebugDraw::DrawSolidCircle(const b2Vec2& center, float32 radius, const b2Vec2& axis, const b2Color& color)
  69. {
  70. const float32 k_segments = 16.0f;
  71. const float32 k_increment = 2.0f * b2_pi / k_segments;
  72. float32 theta = 0.0f;
  73. glEnable(GL_BLEND);
  74. glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  75. glColor4f(0.5f * color.r, 0.5f * color.g, 0.5f * color.b, 0.5f);
  76. glBegin(GL_TRIANGLE_FAN);
  77. for (int32 i = 0; i < k_segments; ++i)
  78. {
  79. b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));
  80. glVertex2f(v.x, v.y);
  81. theta += k_increment;
  82. }
  83. glEnd();
  84. glDisable(GL_BLEND);
  85. theta = 0.0f;
  86. glColor4f(color.r, color.g, color.b, 1.0f);
  87. glBegin(GL_LINE_LOOP);
  88. for (int32 i = 0; i < k_segments; ++i)
  89. {
  90. b2Vec2 v = center + radius * b2Vec2(cosf(theta), sinf(theta));
  91. glVertex2f(v.x, v.y);
  92. theta += k_increment;
  93. }
  94. glEnd();
  95. b2Vec2 p = center + radius * axis;
  96. glBegin(GL_LINES);
  97. glVertex2f(center.x, center.y);
  98. glVertex2f(p.x, p.y);
  99. glEnd();
  100. }
  101. void DebugDraw::DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color)
  102. {
  103. glColor3f(color.r, color.g, color.b);
  104. glBegin(GL_LINES);
  105. glVertex2f(p1.x, p1.y);
  106. glVertex2f(p2.x, p2.y);
  107. glEnd();
  108. }
  109. void DebugDraw::DrawTransform(const b2Transform& xf)
  110. {
  111. b2Vec2 p1 = xf.position, p2;
  112. const float32 k_axisScale = 0.4f;
  113. glBegin(GL_LINES);
  114. glColor3f(1.0f, 0.0f, 0.0f);
  115. glVertex2f(p1.x, p1.y);
  116. p2 = p1 + k_axisScale * xf.R.col1;
  117. glVertex2f(p2.x, p2.y);
  118. glColor3f(0.0f, 1.0f, 0.0f);
  119. glVertex2f(p1.x, p1.y);
  120. p2 = p1 + k_axisScale * xf.R.col2;
  121. glVertex2f(p2.x, p2.y);
  122. glEnd();
  123. }
  124. void DebugDraw::DrawPoint(const b2Vec2& p, float32 size, const b2Color& color)
  125. {
  126. glPointSize(size);
  127. glBegin(GL_POINTS);
  128. glColor3f(color.r, color.g, color.b);
  129. glVertex2f(p.x, p.y);
  130. glEnd();
  131. glPointSize(1.0f);
  132. }
  133. void DebugDraw::DrawString(int x, int y, const char *string, ...)
  134. {
  135. char buffer[128];
  136. va_list arg;
  137. va_start(arg, string);
  138. vsprintf(buffer, string, arg);
  139. va_end(arg);
  140. glMatrixMode(GL_PROJECTION);
  141. glPushMatrix();
  142. glLoadIdentity();
  143. int w = glutGet(GLUT_WINDOW_WIDTH);
  144. int h = glutGet(GLUT_WINDOW_HEIGHT);
  145. gluOrtho2D(0, w, h, 0);
  146. glMatrixMode(GL_MODELVIEW);
  147. glPushMatrix();
  148. glLoadIdentity();
  149. glColor3f(0.9f, 0.6f, 0.6f);
  150. glRasterPos2i(x, y);
  151. int32 length = (int32)strlen(buffer);
  152. for (int32 i = 0; i < length; ++i)
  153. {
  154. glutBitmapCharacter(GLUT_BITMAP_8_BY_13, buffer[i]);
  155. }
  156. glPopMatrix();
  157. glMatrixMode(GL_PROJECTION);
  158. glPopMatrix();
  159. glMatrixMode(GL_MODELVIEW);
  160. }
  161. void DebugDraw::DrawAABB(b2AABB* aabb, const b2Color& c)
  162. {
  163. glColor3f(c.r, c.g, c.b);
  164. glBegin(GL_LINE_LOOP);
  165. glVertex2f(aabb->lowerBound.x, aabb->lowerBound.y);
  166. glVertex2f(aabb->upperBound.x, aabb->lowerBound.y);
  167. glVertex2f(aabb->upperBound.x, aabb->upperBound.y);
  168. glVertex2f(aabb->lowerBound.x, aabb->upperBound.y);
  169. glEnd();
  170. }