PageRenderTime 39ms CodeModel.GetById 9ms RepoModel.GetById 1ms app.codeStats 0ms

/game/q_math.c

https://github.com/xzero450/revolution
C | 1477 lines | 1018 code | 175 blank | 284 comment | 73 complexity | 40f0500e3ddd91e1d1c836b46c6d7c90 MD5 | raw file
    

  1. // Copyright (C) 1999-2000 Id Software, Inc.

    2. 

  2. //

    3. 

  3. // q_math.c -- stateless support routines that are included in each code module

    4. 

  4. #include "q_shared.h"

    5. 

  5. 

    6. 

  6. 

    7. 

  7. #pragma warning( push )

    8. 

  8. #pragma warning(disable : 4305) //shut up the Visual Studio compiler for the color table

    9. 

  9. vec3_t	vec3_origin = {0,0,0};

    10. 

  10. vec3_t	axisDefault[3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };

    11. 

  11. 

    12. 

  12. 

    13. 

  13. vec4_t		colorBlack	= {0, 0, 0, 1};

    14. 

  14. vec4_t		colorRed	= {1, 0, 0, 1};

    15. 

  15. vec4_t		colorGreen	= {0, 1, 0, 1};

    16. 

  16. vec4_t		colorBlue	= {0, 0, 1, 1};

    17. 

  17. vec4_t		colorYellow	= {1, 1, 0, 1};

    18. 

  18. vec4_t		colorMagenta= {1, 0, 1, 1};

    19. 

  19. vec4_t		colorCyan	= {0, 1, 1, 1};

    20. 

  20. vec4_t		colorWhite	= {1, 1, 1, 1};

    21. 

  21. vec4_t		colorOrange = {1, 0.5, 0, 1};

    22. 

  22. vec4_t		colorMdGrey	= {0.5, 0.5, 0.5, 1.0};

    23. 

  23. vec4_t		color_a = {1.00, 0.00, 0.00, 1.00};

    24. 

  24. vec4_t		color_b = {1.00, 0.23, 0.00, 1.00};

    25. 

  25. vec4_t		color_c = {1.00, 0.47, 0.00, 1.00};

    26. 

  26. vec4_t		color_d = {1.00, 0.70, 0.00, 1.00};

    27. 

  27. vec4_t		color_e = {1.00, 0.93, 0.00, 1.00};

    28. 

  28. vec4_t		color_f = {0.83, 1.00, 0.00, 1.00};

    29. 

  29. vec4_t		color_g = {0.60, 1.00, 0.00, 1.00};

    30. 

  30. vec4_t		color_h = {0.37, 1.00, 0.00, 1.00};

    31. 

  31. vec4_t		color_i = {0.13, 1.00, 0.00, 1.00};

    32. 

  32. vec4_t		color_j = {0.00, 1.00, 0.33, 1.00};

    33. 

  33. vec4_t		color_k = {0.00, 1.00, 0.57, 1.00};

    34. 

  34. vec4_t		color_l = {0.00, 1.00, 0.80, 1.00};

    35. 

  35. vec4_t		color_m = {0.00, 0.97, 1.00, 1.00};

    36. 

  36. vec4_t		color_n = {0.00, 0.73, 1.00, 1.00};

    37. 

  37. vec4_t		color_o = {0.00, 0.50, 1.00, 1.00};

    38. 

  38. vec4_t		color_p = {0.00, 0.27, 1.00, 1.00};

    39. 

  39. vec4_t		color_q = {0.00, 0.03, 1.00, 1.00};

    40. 

  40. vec4_t		color_r = {0.20, 0.00, 1.00, 1.00};

    41. 

  41. vec4_t		color_s = {0.43, 0.00, 1.00, 1.00};

    42. 

  42. vec4_t		color_t = {0.67, 0.00, 1.00, 1.00};

    43. 

  43. vec4_t		color_u = {0.90, 0.00, 1.00, 1.00};

    44. 

  44. vec4_t		color_v = {1.00, 0.00, 0.87, 1.00};

    45. 

  45. vec4_t		color_w = {1.00, 0.00, 0.63, 1.00};

    46. 

  46. vec4_t		color_x = {1.00, 0.00, 0.40, 1.00};

    47. 

  47. vec4_t		color_y = {1.00, 1.00, 1.00, 1.00};

    48. 

  48. vec4_t		color_z = {0.25, 0.25, 0.25, 1.00};

    49. 

  49. 

    50. 

  50. vec4_t	g_color_table[62] =

    51. 

  51. 	{

    52. 

  52. 	{0.0, 0.0, 0.0, 1.0},

    53. 

  53. 	{1.0, 0.0, 0.0, 1.0},

    54. 

  54. 	{0.0, 1.0, 0.0, 1.0},

    55. 

  55. 	{1.0, 1.0, 0.0, 1.0},

    56. 

  56. 	{0.0, 0.0, 1.0, 1.0},

    57. 

  57. 	{0.0, 1.0, 1.0, 1.0},

    58. 

  58. 	{1.0, 0.0, 1.0, 1.0},

    59. 

  59. 	{1.0, 1.0, 1.0, 1.0},

    60. 

  60. 	{1.0, 0.5, 0.0, 1.0},

    61. 

  61. 	{0.5, 0.5, 0.5, 1.0},	

    62. 

  62. 	{1.000, 0.000, 0.000, 1.000},

    63. 

  63. 	{1.000, 0.117, 0.000, 1.000},

    64. 

  64. 	{1.000, 0.233, 0.000, 1.000},

    65. 

  65. 	{1.000, 0.350, 0.000, 1.000},

    66. 

  66. 	{1.000, 0.467, 0.000, 1.000},

    67. 

  67. 	{1.000, 0.583, 0.000, 1.000},

    68. 

  68. 	{1.000, 0.700, 0.000, 1.000},

    69. 

  69. 	{1.000, 0.817, 0.000, 1.000},

    70. 

  70. 	{1.000, 0.933, 0.000, 1.000},

    71. 

  71. 	{0.950, 1.000, 0.000, 1.000},

    72. 

  72. 	{0.833, 1.000, 0.000, 1.000},

    73. 

  73. 	{0.717, 1.000, 0.000, 1.000},

    74. 

  74. 	{0.600, 1.000, 0.000, 1.000},

    75. 

  75. 	{0.483, 1.000, 0.000, 1.000},

    76. 

  76. 	{0.367, 1.000, 0.000, 1.000},

    77. 

  77. 	{0.250, 1.000, 0.000, 1.000},

    78. 

  78. 	{0.133, 1.000, 0.000, 1.000},

    79. 

  79. 	{0.017, 1.000, 0.000, 1.000},

    80. 

  80. 	{0.000, 1.000, 0.100, 1.000},

    81. 

  81. 	{0.000, 1.000, 0.217, 1.000},

    82. 

  82. 	{0.000, 1.000, 0.333, 1.000},

    83. 

  83. 	{0.000, 1.000, 0.450, 1.000},

    84. 

  84. 	{0.000, 1.000, 0.567, 1.000},

    85. 

  85. 	{0.000, 1.000, 0.683, 1.000},

    86. 

  86. 	{0.000, 1.000, 0.800, 1.000},

    87. 

  87. 	{0.000, 1.000, 0.917, 1.000},

    88. 

  88. 	{0.000, 0.967, 1.000, 1.000},

    89. 

  89. 	{0.000, 0.850, 1.000, 1.000},

    90. 

  90. 	{0.000, 0.733, 1.000, 1.000},

    91. 

  91. 	{0.000, 0.617, 1.000, 1.000},

    92. 

  92. 	{0.000, 0.500, 1.000, 1.000},

    93. 

  93. 	{0.000, 0.383, 1.000, 1.000},

    94. 

  94. 	{0.000, 0.267, 1.000, 1.000},

    95. 

  95. 	{0.000, 0.150, 1.000, 1.000},

    96. 

  96. 	{0.000, 0.033, 1.000, 1.000},

    97. 

  97. 	{0.083, 0.000, 1.000, 1.000},

    98. 

  98. 	{0.200, 0.000, 1.000, 1.000},

    99. 

  99. 	{0.317, 0.000, 1.000, 1.000},

    100. 

  100. 	{0.433, 0.000, 1.000, 1.000},

    101. 

  101. 	{0.550, 0.000, 1.000, 1.000},

    102. 

  102. 	{0.667, 0.000, 1.000, 1.000},

    103. 

  103. 	{0.783, 0.000, 1.000, 1.000},

    104. 

  104. 	{0.900, 0.000, 1.000, 1.000},

    105. 

  105. 	{1.000, 0.000, 0.983, 1.000},

    106. 

  106. 	{1.000, 0.000, 0.867, 1.000},

    107. 

  107. 	{1.000, 0.000, 0.750, 1.000},

    108. 

  108. 	{1.000, 0.000, 0.633, 1.000},

    109. 

  109. 	{1.000, 0.000, 0.517, 1.000},

    110. 

  110. 	{1.00, 1.00, 1.00, 1.00},

    111. 

  111. 	{0.25, 0.25, 0.25, 1.00},

    112. 

  112. 	{0.75, 0.75, 0.75, 1.00},

    113. 

  113. 	{0.50, 0.50, 0.50, 1.00}

    114. 

  114. 	//};

    115. 

  115. 

    116. 

  116. 	/*{1.00, 0.00, 0.00, 1.00},

    117. 

  117. 	{1.00, 0.23, 0.00, 1.00},

    118. 

  118. 	{1.00, 0.47, 0.00, 1.00},

    119. 

  119. 	{1.00, 0.70, 0.00, 1.00},

    120. 

  120. 	{1.00, 0.93, 0.00, 1.00},

    121. 

  121. 	{0.83, 1.00, 0.00, 1.00},

    122. 

  122. 	{0.60, 1.00, 0.00, 1.00},

    123. 

  123. 	{0.37, 1.00, 0.00, 1.00},

    124. 

  124. 	{0.13, 1.00, 0.00, 1.00},

    125. 

  125. 	{0.00, 1.00, 0.33, 1.00},

    126. 

  126. 	{0.00, 1.00, 0.57, 1.00},

    127. 

  127. 	{0.00, 1.00, 0.80, 1.00},

    128. 

  128. 	{0.00, 0.97, 1.00, 1.00},

    129. 

  129. 	{0.00, 0.73, 1.00, 1.00},

    130. 

  130. 	{0.00, 0.50, 1.00, 1.00},

    131. 

  131. 	{0.00, 0.27, 1.00, 1.00},

    132. 

  132. 	{0.00, 0.03, 1.00, 1.00},

    133. 

  133. 	{0.20, 0.00, 1.00, 1.00},

    134. 

  134. 	{0.43, 0.00, 1.00, 1.00},

    135. 

  135. 	{0.67, 0.00, 1.00, 1.00},

    136. 

  136. 	{0.90, 0.00, 1.00, 1.00},

    137. 

  137. 	{1.00, 0.00, 0.87, 1.00},

    138. 

  138. 	{1.00, 0.00, 0.63, 1.00},

    139. 

  139. 	{1.00, 0.00, 0.40, 1.00},

    140. 

  140. 	{1.00, 1.00, 1.00, 1.00},

    141. 

  141. 	{0.25, 0.25, 0.25, 1.00}*/

    142. 

  142. 

    143. 

  143. 

    144. 

  144. 	/*

    145. 

  145. 	{0.75, 0.1, 0.1, 1.0},

    146. 

  146. 	{0.9, 0.25, 0.1, 1.0},

    147. 

  147. 	{0.8, 0.55, 0.25, 1.0},

    148. 

  148. 	{0.85, 0.7, 0.2, 1.0},

    149. 

  149. 	{0.95, 0.95, 0.4, 1.0},

    150. 

  150. 	{0.7, 0.85, 0.4, 1.0},

    151. 

  151. 	{0.6, 0.8, 0.25, 1.0},

    152. 

  152. 	{0.4, 0.95, 0.3, 1.0},

    153. 

  153. 	{0.2, 0.75, 0.2, 1.0},

    154. 

  154. 	{0.35, 0.75, 0.5, 1.0},

    155. 

  155. 	{0.2, 0.95, 0.55, 1.0},

    156. 

  156. 	{0.45, 0.8, 0.7, 1.0},

    157. 

  157. 	{0.1, 0.9, 0.9, 1.0},

    158. 

  158. 	{0.1, 0.6, 0.9, 1.0},

    159. 

  159. 	{0.15, 0.45, 0.7, 1.0},

    160. 

  160. 	{0.15, 0.25, 0.75, 1.0},

    161. 

  161. 	{0.0, 0.0, 0.7, 1.0},

    162. 

  162. 	{0.25, 0.05, 0.85, 1.0},

    163. 

  163. 	{0.4, 0.1, 0.65, 1.0},

    164. 

  164. 	{0.5, 0.15, 0.75, 1.0},

    165. 

  165. 	{0.7, 0.15, 0.7, 1.0},

    166. 

  166. 	{0.75, 0.2, 0.55, 1.0},

    167. 

  167. 	{1.0, 0.1, 0.45, 1.0},

    168. 

  168. 	{0.8, 0.1, 0.25, 1.0},

    169. 

  169. 	{1.0, 1.0, 1.0, 1.0},

    170. 

  170. 	{0.25, 0.25, 0.25, 1.0},

    171. 

  171. 	{0.75, 0.1, 0.1, 1.0},

    172. 

  172. 	{0.9, 0.25, 0.1, 1.0},

    173. 

  173. 	{0.8, 0.55, 0.25, 1.0},

    174. 

  174. 	{0.85, 0.7, 0.2, 1.0},

    175. 

  175. 	{0.95, 0.95, 0.4, 1.0},

    176. 

  176. 	{0.7, 0.85, 0.4, 1.0},

    177. 

  177. 	{0.6, 0.8, 0.25, 1.0},

    178. 

  178. 	{0.4, 0.95, 0.3, 1.0},

    179. 

  179. 	{0.2, 0.75, 0.2, 1.0},

    180. 

  180. 	{0.35, 0.75, 0.5, 1.0},

    181. 

  181. 	{0.2, 0.95, 0.55, 1.0},

    182. 

  182. 	{0.45, 0.8, 0.7, 1.0},

    183. 

  183. 	{0.1, 0.9, 0.9, 1.0},

    184. 

  184. 	{0.1, 0.6, 0.9, 1.0},

    185. 

  185. 	{0.15, 0.45, 0.7, 1.0},

    186. 

  186. 	{0.15, 0.25, 0.75, 1.0},

    187. 

  187. 	{0.0, 0.0, 0.7, 1.0},

    188. 

  188. 	{0.25, 0.05, 0.85, 1.0},

    189. 

  189. 	{0.4, 0.1, 0.65, 1.0},

    190. 

  190. 	{0.5, 0.15, 0.75, 1.0},

    191. 

  191. 	{0.7, 0.15, 0.7, 1.0},

    192. 

  192. 	{0.75, 0.2, 0.55, 1.0},

    193. 

  193. 	{1.0, 0.1, 0.45, 1.0},

    194. 

  194. 	{0.8, 0.1, 0.25, 1.0},

    195. 

  195. 	{1.0, 1.0, 1.0, 1.0},

    196. 

  196. 	{0.25, 0.25, 0.25, 1.0}*/

    197. 

  197. 	/*

    198. 

  198. 	//{0.5, 0.5, 0.5, 1.0},

    199. 

  199. 	//{0.0, 0.0, 0.75, 1.0},

    200. 

  200. 	//{0.75, 0.0, 0.0, 1.0},{1.0, 0.0, 0.5, 1.0},

    201. 

  201. 	{0.25, 0.0, 0.5, 1.0},

    202. 

  202. 	{1.0, 0.0, 0.25,1},

    203. 

  203. 	{1.0, 1.0, 0.0, 1.0},

    204. 

  204. 	{1.0, 0.5, 0.0, 1.0},

    205. 

  205. 	{1.0, 0.25, 0.0, 1.0},

    206. 

  206. 	{0.25, 0.0, 1.0, 1.0},

    207. 

  207. 	{0.5, 1.0, 0.0, 1.0},

    208. 

  208. 	{1.0, 0.0, 0.5, 1.0},

    209. 

  209. 	{0.5, 0.0, 1.0, 1.0},

    210. 

  210. 	{0.25, 1.0, 0.0, 1.0},

    211. 

  211. 	{0.75, 0.75, 0.75, 1.0},

    212. 

  212. 	{0.25, 1.0, 0.0, 1.0},

    213. 

  213. 	{0.0, 0.5, 1.0, 1.0},

    214. 

  214. 	{0.0, 0.75, 1.0, 1.0},

    215. 

  215. 	{0.0, 0.25, 0.75, 1.0},

    216. 

  216. 	{0.0, 0.25, 0.25, 1.0},

    217. 

  217. 	{0.0, 1.0, 0.0, 1.0},

    218. 

  218. 	{0.0, 0.5, 0.75, 1.0},

    219. 

  219. 	{0.5, 0.5, 0.5, 1.0},

    220. 

  220. 	{0.0, 0.0, 0.75, 1.0},

    221. 

  221. 	{0.0, 0.75, 0.75, 1.0},

    222. 

  222. 	{1.0, 0.0, 0.5, 1.0},*/

    223. 

  223. 	};

    224. 

  224. #pragma warning( pop ) //shut up the Visual Studio compiler for the color table

    225. 

  225. 

    226. 

  226. vec3_t	bytedirs[NUMVERTEXNORMALS] =

    227. 

  227. {

    228. 

  228. {-0.525731f, 0.000000f, 0.850651f}, {-0.442863f, 0.238856f, 0.864188f}, 

    229. 

  229. {-0.295242f, 0.000000f, 0.955423f}, {-0.309017f, 0.500000f, 0.809017f}, 

    230. 

  230. {-0.162460f, 0.262866f, 0.951056f}, {0.000000f, 0.000000f, 1.000000f}, 

    231. 

  231. {0.000000f, 0.850651f, 0.525731f}, {-0.147621f, 0.716567f, 0.681718f}, 

    232. 

  232. {0.147621f, 0.716567f, 0.681718f}, {0.000000f, 0.525731f, 0.850651f}, 

    233. 

  233. {0.309017f, 0.500000f, 0.809017f}, {0.525731f, 0.000000f, 0.850651f}, 

    234. 

  234. {0.295242f, 0.000000f, 0.955423f}, {0.442863f, 0.238856f, 0.864188f}, 

    235. 

  235. {0.162460f, 0.262866f, 0.951056f}, {-0.681718f, 0.147621f, 0.716567f}, 

    236. 

  236. {-0.809017f, 0.309017f, 0.500000f},{-0.587785f, 0.425325f, 0.688191f}, 

    237. 

  237. {-0.850651f, 0.525731f, 0.000000f},{-0.864188f, 0.442863f, 0.238856f}, 

    238. 

  238. {-0.716567f, 0.681718f, 0.147621f},{-0.688191f, 0.587785f, 0.425325f}, 

    239. 

  239. {-0.500000f, 0.809017f, 0.309017f}, {-0.238856f, 0.864188f, 0.442863f}, 

    240. 

  240. {-0.425325f, 0.688191f, 0.587785f}, {-0.716567f, 0.681718f, -0.147621f}, 

    241. 

  241. {-0.500000f, 0.809017f, -0.309017f}, {-0.525731f, 0.850651f, 0.000000f}, 

    242. 

  242. {0.000000f, 0.850651f, -0.525731f}, {-0.238856f, 0.864188f, -0.442863f}, 

    243. 

  243. {0.000000f, 0.955423f, -0.295242f}, {-0.262866f, 0.951056f, -0.162460f}, 

    244. 

  244. {0.000000f, 1.000000f, 0.000000f}, {0.000000f, 0.955423f, 0.295242f}, 

    245. 

  245. {-0.262866f, 0.951056f, 0.162460f}, {0.238856f, 0.864188f, 0.442863f}, 

    246. 

  246. {0.262866f, 0.951056f, 0.162460f}, {0.500000f, 0.809017f, 0.309017f}, 

    247. 

  247. {0.238856f, 0.864188f, -0.442863f},{0.262866f, 0.951056f, -0.162460f}, 

    248. 

  248. {0.500000f, 0.809017f, -0.309017f},{0.850651f, 0.525731f, 0.000000f}, 

    249. 

  249. {0.716567f, 0.681718f, 0.147621f}, {0.716567f, 0.681718f, -0.147621f}, 

    250. 

  250. {0.525731f, 0.850651f, 0.000000f}, {0.425325f, 0.688191f, 0.587785f}, 

    251. 

  251. {0.864188f, 0.442863f, 0.238856f}, {0.688191f, 0.587785f, 0.425325f}, 

    252. 

  252. {0.809017f, 0.309017f, 0.500000f}, {0.681718f, 0.147621f, 0.716567f}, 

    253. 

  253. {0.587785f, 0.425325f, 0.688191f}, {0.955423f, 0.295242f, 0.000000f}, 

    254. 

  254. {1.000000f, 0.000000f, 0.000000f}, {0.951056f, 0.162460f, 0.262866f}, 

    255. 

  255. {0.850651f, -0.525731f, 0.000000f},{0.955423f, -0.295242f, 0.000000f}, 

    256. 

  256. {0.864188f, -0.442863f, 0.238856f}, {0.951056f, -0.162460f, 0.262866f}, 

    257. 

  257. {0.809017f, -0.309017f, 0.500000f}, {0.681718f, -0.147621f, 0.716567f}, 

    258. 

  258. {0.850651f, 0.000000f, 0.525731f}, {0.864188f, 0.442863f, -0.238856f}, 

    259. 

  259. {0.809017f, 0.309017f, -0.500000f}, {0.951056f, 0.162460f, -0.262866f}, 

    260. 

  260. {0.525731f, 0.000000f, -0.850651f}, {0.681718f, 0.147621f, -0.716567f}, 

    261. 

  261. {0.681718f, -0.147621f, -0.716567f},{0.850651f, 0.000000f, -0.525731f}, 

    262. 

  262. {0.809017f, -0.309017f, -0.500000f}, {0.864188f, -0.442863f, -0.238856f}, 

    263. 

  263. {0.951056f, -0.162460f, -0.262866f}, {0.147621f, 0.716567f, -0.681718f}, 

    264. 

  264. {0.309017f, 0.500000f, -0.809017f}, {0.425325f, 0.688191f, -0.587785f}, 

    265. 

  265. {0.442863f, 0.238856f, -0.864188f}, {0.587785f, 0.425325f, -0.688191f}, 

    266. 

  266. {0.688191f, 0.587785f, -0.425325f}, {-0.147621f, 0.716567f, -0.681718f}, 

    267. 

  267. {-0.309017f, 0.500000f, -0.809017f}, {0.000000f, 0.525731f, -0.850651f}, 

    268. 

  268. {-0.525731f, 0.000000f, -0.850651f}, {-0.442863f, 0.238856f, -0.864188f}, 

    269. 

  269. {-0.295242f, 0.000000f, -0.955423f}, {-0.162460f, 0.262866f, -0.951056f}, 

    270. 

  270. {0.000000f, 0.000000f, -1.000000f}, {0.295242f, 0.000000f, -0.955423f}, 

    271. 

  271. {0.162460f, 0.262866f, -0.951056f}, {-0.442863f, -0.238856f, -0.864188f}, 

    272. 

  272. {-0.309017f, -0.500000f, -0.809017f}, {-0.162460f, -0.262866f, -0.951056f}, 

    273. 

  273. {0.000000f, -0.850651f, -0.525731f}, {-0.147621f, -0.716567f, -0.681718f}, 

    274. 

  274. {0.147621f, -0.716567f, -0.681718f}, {0.000000f, -0.525731f, -0.850651f}, 

    275. 

  275. {0.309017f, -0.500000f, -0.809017f}, {0.442863f, -0.238856f, -0.864188f}, 

    276. 

  276. {0.162460f, -0.262866f, -0.951056f}, {0.238856f, -0.864188f, -0.442863f}, 

    277. 

  277. {0.500000f, -0.809017f, -0.309017f}, {0.425325f, -0.688191f, -0.587785f}, 

    278. 

  278. {0.716567f, -0.681718f, -0.147621f}, {0.688191f, -0.587785f, -0.425325f}, 

    279. 

  279. {0.587785f, -0.425325f, -0.688191f}, {0.000000f, -0.955423f, -0.295242f}, 

    280. 

  280. {0.000000f, -1.000000f, 0.000000f}, {0.262866f, -0.951056f, -0.162460f}, 

    281. 

  281. {0.000000f, -0.850651f, 0.525731f}, {0.000000f, -0.955423f, 0.295242f}, 

    282. 

  282. {0.238856f, -0.864188f, 0.442863f}, {0.262866f, -0.951056f, 0.162460f}, 

    283. 

  283. {0.500000f, -0.809017f, 0.309017f}, {0.716567f, -0.681718f, 0.147621f}, 

    284. 

  284. {0.525731f, -0.850651f, 0.000000f}, {-0.238856f, -0.864188f, -0.442863f}, 

    285. 

  285. {-0.500000f, -0.809017f, -0.309017f}, {-0.262866f, -0.951056f, -0.162460f}, 

    286. 

  286. {-0.850651f, -0.525731f, 0.000000f}, {-0.716567f, -0.681718f, -0.147621f}, 

    287. 

  287. {-0.716567f, -0.681718f, 0.147621f}, {-0.525731f, -0.850651f, 0.000000f}, 

    288. 

  288. {-0.500000f, -0.809017f, 0.309017f}, {-0.238856f, -0.864188f, 0.442863f}, 

    289. 

  289. {-0.262866f, -0.951056f, 0.162460f}, {-0.864188f, -0.442863f, 0.238856f}, 

    290. 

  290. {-0.809017f, -0.309017f, 0.500000f}, {-0.688191f, -0.587785f, 0.425325f}, 

    291. 

  291. {-0.681718f, -0.147621f, 0.716567f}, {-0.442863f, -0.238856f, 0.864188f}, 

    292. 

  292. {-0.587785f, -0.425325f, 0.688191f}, {-0.309017f, -0.500000f, 0.809017f}, 

    293. 

  293. {-0.147621f, -0.716567f, 0.681718f}, {-0.425325f, -0.688191f, 0.587785f}, 

    294. 

  294. {-0.162460f, -0.262866f, 0.951056f}, {0.442863f, -0.238856f, 0.864188f}, 

    295. 

  295. {0.162460f, -0.262866f, 0.951056f}, {0.309017f, -0.500000f, 0.809017f}, 

    296. 

  296. {0.147621f, -0.716567f, 0.681718f}, {0.000000f, -0.525731f, 0.850651f}, 

    297. 

  297. {0.425325f, -0.688191f, 0.587785f}, {0.587785f, -0.425325f, 0.688191f}, 

    298. 

  298. {0.688191f, -0.587785f, 0.425325f}, {-0.955423f, 0.295242f, 0.000000f}, 

    299. 

  299. {-0.951056f, 0.162460f, 0.262866f}, {-1.000000f, 0.000000f, 0.000000f}, 

    300. 

  300. {-0.850651f, 0.000000f, 0.525731f}, {-0.955423f, -0.295242f, 0.000000f}, 

    301. 

  301. {-0.951056f, -0.162460f, 0.262866f}, {-0.864188f, 0.442863f, -0.238856f}, 

    302. 

  302. {-0.951056f, 0.162460f, -0.262866f}, {-0.809017f, 0.309017f, -0.500000f}, 

    303. 

  303. {-0.864188f, -0.442863f, -0.238856f}, {-0.951056f, -0.162460f, -0.262866f}, 

    304. 

  304. {-0.809017f, -0.309017f, -0.500000f}, {-0.681718f, 0.147621f, -0.716567f}, 

    305. 

  305. {-0.681718f, -0.147621f, -0.716567f}, {-0.850651f, 0.000000f, -0.525731f}, 

    306. 

  306. {-0.688191f, 0.587785f, -0.425325f}, {-0.587785f, 0.425325f, -0.688191f}, 

    307. 

  307. {-0.425325f, 0.688191f, -0.587785f}, {-0.425325f, -0.688191f, -0.587785f}, 

    308. 

  308. {-0.587785f, -0.425325f, -0.688191f}, {-0.688191f, -0.587785f, -0.425325f}

    309. 

  309. };

    310. 

  310. 

    311. 

  311. //==============================================================

    312. 

  312. 

    313. 

  313. int		Q_rand( int *seed ) {

    314. 

  314. 	*seed = (69069 * *seed + 1);

    315. 

  315. 	return *seed;

    316. 

  316. }

    317. 

  317. 

    318. 

  318. float	Q_random( int *seed ) {

    319. 

  319. 	return ( Q_rand( seed ) & 0xffff ) / (float)0x10000;

    320. 

  320. }

    321. 

  321. 

    322. 

  322. float	Q_crandom( int *seed ) {

    323. 

  323. 	return 2.0 * ( Q_random( seed ) - 0.5 );

    324. 

  324. }

    325. 

  325. 

    326. 

  326. #ifdef __LCC__

    327. 

  327. 

    328. 

  328. int VectorCompare( const vec3_t v1, const vec3_t v2 ) {

    329. 

  329. 	if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) {

    330. 

  330. 		return 0;

    331. 

  331. 	}			

    332. 

  332. 	return 1;

    333. 

  333. }

    334. 

  334. 

    335. 

  335. vec_t VectorLength( const vec3_t v ) {

    336. 

  336. 	return (vec_t)sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);

    337. 

  337. }

    338. 

  338. 

    339. 

  339. vec_t VectorLengthSquared( const vec3_t v ) {

    340. 

  340. 	return (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);

    341. 

  341. }

    342. 

  342. 

    343. 

  343. vec_t Distance( const vec3_t p1, const vec3_t p2 ) {

    344. 

  344. 	vec3_t	v;

    345. 

  345. 

    346. 

  346. 	VectorSubtract (p2, p1, v);

    347. 

  347. 	return VectorLength( v );

    348. 

  348. }

    349. 

  349. 

    350. 

  350. vec_t DistanceSquared( const vec3_t p1, const vec3_t p2 ) {

    351. 

  351. 	vec3_t	v;

    352. 

  352. 

    353. 

  353. 	VectorSubtract (p2, p1, v);

    354. 

  354. 	return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];

    355. 

  355. }

    356. 

  356. 

    357. 

  357. // fast vector normalize routine that does not check to make sure

    358. 

  358. // that length != 0, nor does it return length, uses rsqrt approximation

    359. 

  359. void VectorNormalizeFast( vec3_t v )

    360. 

  360. {

    361. 

  361. 	float ilength;

    362. 

  362. 

    363. 

  363. 	ilength = Q_rsqrt( DotProduct( v, v ) );

    364. 

  364. 

    365. 

  365. 	v[0] *= ilength;

    366. 

  366. 	v[1] *= ilength;

    367. 

  367. 	v[2] *= ilength;

    368. 

  368. }

    369. 

  369. 

    370. 

  370. void VectorInverse( vec3_t v ){

    371. 

  371. 	v[0] = -v[0];

    372. 

  372. 	v[1] = -v[1];

    373. 

  373. 	v[2] = -v[2];

    374. 

  374. }

    375. 

  375. 

    376. 

  376. void CrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross ) {

    377. 

  377. 	cross[0] = v1[1]*v2[2] - v1[2]*v2[1];

    378. 

  378. 	cross[1] = v1[2]*v2[0] - v1[0]*v2[2];

    379. 

  379. 	cross[2] = v1[0]*v2[1] - v1[1]*v2[0];

    380. 

  380. }

    381. 

  381. #endif

    382. 

  382. 

    383. 

  383. //=======================================================

    384. 

  384. 

    385. 

  385. signed char ClampChar( int i ) {

    386. 

  386. 	if ( i < -128 ) {

    387. 

  387. 		return -128;

    388. 

  388. 	}

    389. 

  389. 	if ( i > 127 ) {

    390. 

  390. 		return 127;

    391. 

  391. 	}

    392. 

  392. 	return i;

    393. 

  393. }

    394. 

  394. 

    395. 

  395. signed short ClampShort( int i ) {

    396. 

  396. 	if ( i < -32768 ) {

    397. 

  397. 		return -32768;

    398. 

  398. 	}

    399. 

  399. 	if ( i > 0x7fff ) {

    400. 

  400. 		return 0x7fff;

    401. 

  401. 	}

    402. 

  402. 	return i;

    403. 

  403. }

    404. 

  404. 

    405. 

  405. 

    406. 

  406. // this isn't a real cheap function to call!

    407. 

  407. int DirToByte( vec3_t dir ) {

    408. 

  408. 	int		i, best;

    409. 

  409. 	float	d, bestd;

    410. 

  410. 

    411. 

  411. 	if ( !dir ) {

    412. 

  412. 		return 0;

    413. 

  413. 	}

    414. 

  414. 

    415. 

  415. 	bestd = 0;

    416. 

  416. 	best = 0;

    417. 

  417. 	for (i=0 ; i<NUMVERTEXNORMALS ; i++)

    418. 

  418. 	{

    419. 

  419. 		d = DotProduct (dir, bytedirs[i]);

    420. 

  420. 		if (d > bestd)

    421. 

  421. 		{

    422. 

  422. 			bestd = d;

    423. 

  423. 			best = i;

    424. 

  424. 		}

    425. 

  425. 	}

    426. 

  426. 

    427. 

  427. 	return best;

    428. 

  428. }

    429. 

  429. 

    430. 

  430. void ByteToDir( int b, vec3_t dir ) {

    431. 

  431. 	if ( b < 0 || b >= NUMVERTEXNORMALS ) {

    432. 

  432. 		VectorCopy( vec3_origin, dir );

    433. 

  433. 		return;

    434. 

  434. 	}

    435. 

  435. 	VectorCopy (bytedirs[b], dir);

    436. 

  436. }

    437. 

  437. 

    438. 

  438. 

    439. 

  439. unsigned ColorBytes3 (float r, float g, float b) {

    440. 

  440. 	unsigned	i;

    441. 

  441. 

    442. 

  442. 	( (byte *)&i )[0] = r * 255;

    443. 

  443. 	( (byte *)&i )[1] = g * 255;

    444. 

  444. 	( (byte *)&i )[2] = b * 255;

    445. 

  445. 

    446. 

  446. 	return i;

    447. 

  447. }

    448. 

  448. 

    449. 

  449. unsigned ColorBytes4 (float r, float g, float b, float a) {

    450. 

  450. 	unsigned	i;

    451. 

  451. 

    452. 

  452. 	( (byte *)&i )[0] = r * 255;

    453. 

  453. 	( (byte *)&i )[1] = g * 255;

    454. 

  454. 	( (byte *)&i )[2] = b * 255;

    455. 

  455. 	( (byte *)&i )[3] = a * 255;

    456. 

  456. 

    457. 

  457. 	return i;

    458. 

  458. }

    459. 

  459. 

    460. 

  460. float NormalizeColor( const vec3_t in, vec3_t out ) {

    461. 

  461. 	float	max;

    462. 

  462. 	

    463. 

  463. 	max = in[0];

    464. 

  464. 	if ( in[1] > max ) {

    465. 

  465. 		max = in[1];

    466. 

  466. 	}

    467. 

  467. 	if ( in[2] > max ) {

    468. 

  468. 		max = in[2];

    469. 

  469. 	}

    470. 

  470. 

    471. 

  471. 	if ( !max ) {

    472. 

  472. 		VectorClear( out );

    473. 

  473. 	} else {

    474. 

  474. 		out[0] = in[0] / max;

    475. 

  475. 		out[1] = in[1] / max;

    476. 

  476. 		out[2] = in[2] / max;

    477. 

  477. 	}

    478. 

  478. 	return max;

    479. 

  479. }

    480. 

  480. 

    481. 

  481. 

    482. 

  482. /*

    483. 

  483. =====================

    484. 

  484. PlaneFromPoints

    485. 

  485. 

    486. 

  486. Returns false if the triangle is degenrate.

    487. 

  487. The normal will point out of the clock for clockwise ordered points

    488. 

  488. =====================

    489. 

  489. */

    490. 

  490. qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c ) {

    491. 

  491. 	vec3_t	d1, d2;

    492. 

  492. 

    493. 

  493. 	VectorSubtract( b, a, d1 );

    494. 

  494. 	VectorSubtract( c, a, d2 );

    495. 

  495. 	CrossProduct( d2, d1, plane );

    496. 

  496. 	if ( VectorNormalize( plane ) == 0 ) {

    497. 

  497. 		return qfalse;

    498. 

  498. 	}

    499. 

  499. 

    500. 

  500. 	plane[3] = DotProduct( a, plane );

    501. 

  501. 	return qtrue;

    502. 

  502. }

    503. 

  503. 

    504. 

  504. /*

    505. 

  505. ===============

    506. 

  506. RotatePointAroundVector

    507. 

  507. 

    508. 

  508. This is not implemented very well...

    509. 

  509. ===============

    510. 

  510. */

    511. 

  511. void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,

    512. 

  512. 							 float degrees ) {

    513. 

  513. 	float	m[3][3];

    514. 

  514. 	float	im[3][3];

    515. 

  515. 	float	zrot[3][3];

    516. 

  516. 	float	tmpmat[3][3];

    517. 

  517. 	float	rot[3][3];

    518. 

  518. 	int	i;

    519. 

  519. 	vec3_t vr, vup, vf;

    520. 

  520. 	float	rad;

    521. 

  521. 

    522. 

  522. 	vf[0] = dir[0];

    523. 

  523. 	vf[1] = dir[1];

    524. 

  524. 	vf[2] = dir[2];

    525. 

  525. 

    526. 

  526. 	PerpendicularVector( vr, dir );

    527. 

  527. 	CrossProduct( vr, vf, vup );

    528. 

  528. 

    529. 

  529. 	m[0][0] = vr[0];

    530. 

  530. 	m[1][0] = vr[1];

    531. 

  531. 	m[2][0] = vr[2];

    532. 

  532. 

    533. 

  533. 	m[0][1] = vup[0];

    534. 

  534. 	m[1][1] = vup[1];

    535. 

  535. 	m[2][1] = vup[2];

    536. 

  536. 

    537. 

  537. 	m[0][2] = vf[0];

    538. 

  538. 	m[1][2] = vf[1];

    539. 

  539. 	m[2][2] = vf[2];

    540. 

  540. 

    541. 

  541. 	memcpy( im, m, sizeof( im ) );

    542. 

  542. 

    543. 

  543. 	im[0][1] = m[1][0];

    544. 

  544. 	im[0][2] = m[2][0];

    545. 

  545. 	im[1][0] = m[0][1];

    546. 

  546. 	im[1][2] = m[2][1];

    547. 

  547. 	im[2][0] = m[0][2];

    548. 

  548. 	im[2][1] = m[1][2];

    549. 

  549. 

    550. 

  550. 	memset( zrot, 0, sizeof( zrot ) );

    551. 

  551. 	zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;

    552. 

  552. 

    553. 

  553. 	rad = DEG2RAD( degrees );

    554. 

  554. 	zrot[0][0] = cos( rad );

    555. 

  555. 	zrot[0][1] = sin( rad );

    556. 

  556. 	zrot[1][0] = -sin( rad );

    557. 

  557. 	zrot[1][1] = cos( rad );

    558. 

  558. 

    559. 

  559. 	MatrixMultiply( m, zrot, tmpmat );

    560. 

  560. 	MatrixMultiply( tmpmat, im, rot );

    561. 

  561. 

    562. 

  562. 	for ( i = 0; i < 3; i++ ) {

    563. 

  563. 		dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];

    564. 

  564. 	}

    565. 

  565. }

    566. 

  566. 

    567. 

  567. /*

    568. 

  568. ===============

    569. 

  569. RotateAroundDirection

    570. 

  570. ===============

    571. 

  571. */

    572. 

  572. void RotateAroundDirection( vec3_t axis[3], float yaw ) {

    573. 

  573. 

    574. 

  574. 	// create an arbitrary axis[1] 

    575. 

  575. 	PerpendicularVector( axis[1], axis[0] );

    576. 

  576. 

    577. 

  577. 	// rotate it around axis[0] by yaw

    578. 

  578. 	if ( yaw ) {

    579. 

  579. 		vec3_t	temp;

    580. 

  580. 

    581. 

  581. 		VectorCopy( axis[1], temp );

    582. 

  582. 		RotatePointAroundVector( axis[1], axis[0], temp, yaw );

    583. 

  583. 	}

    584. 

  584. 

    585. 

  585. 	// cross to get axis[2]

    586. 

  586. 	CrossProduct( axis[0], axis[1], axis[2] );

    587. 

  587. }

    588. 

  588. 

    589. 

  589. 

    590. 

  590. 

    591. 

  591. void vectoangles( const vec3_t value1, vec3_t angles ) {

    592. 

  592. 	float	forward;

    593. 

  593. 	float	yaw, pitch;

    594. 

  594. 	

    595. 

  595. 	if ( value1[1] == 0 && value1[0] == 0 ) {

    596. 

  596. 		yaw = 0;

    597. 

  597. 		if ( value1[2] > 0 ) {

    598. 

  598. 			pitch = 90;

    599. 

  599. 		}

    600. 

  600. 		else {

    601. 

  601. 			pitch = 270;

    602. 

  602. 		}

    603. 

  603. 	}

    604. 

  604. 	else {

    605. 

  605. 		if ( value1[0] ) {

    606. 

  606. 			yaw = ( atan2 ( value1[1], value1[0] ) * 180 / M_PI );

    607. 

  607. 		}

    608. 

  608. 		else if ( value1[1] > 0 ) {

    609. 

  609. 			yaw = 90;

    610. 

  610. 		}

    611. 

  611. 		else {

    612. 

  612. 			yaw = 270;

    613. 

  613. 		}

    614. 

  614. 		if ( yaw < 0 ) {

    615. 

  615. 			yaw += 360;

    616. 

  616. 		}

    617. 

  617. 

    618. 

  618. 		forward = sqrt ( value1[0]*value1[0] + value1[1]*value1[1] );

    619. 

  619. 		pitch = ( atan2(value1[2], forward) * 180 / M_PI );

    620. 

  620. 		if ( pitch < 0 ) {

    621. 

  621. 			pitch += 360;

    622. 

  622. 		}

    623. 

  623. 	}

    624. 

  624. 

    625. 

  625. 	angles[PITCH] = -pitch;

    626. 

  626. 	angles[YAW] = yaw;

    627. 

  627. 	angles[ROLL] = 0;

    628. 

  628. }

    629. 

  629. 

    630. 

  630. 

    631. 

  631. /*

    632. 

  632. =================

    633. 

  633. AnglesToAxis

    634. 

  634. =================

    635. 

  635. */

    636. 

  636. void AnglesToAxis( const vec3_t angles, vec3_t axis[3] ) {

    637. 

  637. 	vec3_t	right;

    638. 

  638. 

    639. 

  639. 	// angle vectors returns "right" instead of "y axis"

    640. 

  640. 	AngleVectors( angles, axis[0], right, axis[2] );

    641. 

  641. 	VectorSubtract( vec3_origin, right, axis[1] );

    642. 

  642. }

    643. 

  643. 

    644. 

  644. void AxisClear( vec3_t axis[3] ) {

    645. 

  645. 	axis[0][0] = 1;

    646. 

  646. 	axis[0][1] = 0;

    647. 

  647. 	axis[0][2] = 0;

    648. 

  648. 	axis[1][0] = 0;

    649. 

  649. 	axis[1][1] = 1;

    650. 

  650. 	axis[1][2] = 0;

    651. 

  651. 	axis[2][0] = 0;

    652. 

  652. 	axis[2][1] = 0;

    653. 

  653. 	axis[2][2] = 1;

    654. 

  654. }

    655. 

  655. 

    656. 

  656. void AxisCopy( vec3_t in[3], vec3_t out[3] ) {

    657. 

  657. 	VectorCopy( in[0], out[0] );

    658. 

  658. 	VectorCopy( in[1], out[1] );

    659. 

  659. 	VectorCopy( in[2], out[2] );

    660. 

  660. }

    661. 

  661. 

    662. 

  662. void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )

    663. 

  663. {

    664. 

  664. 	float d;

    665. 

  665. 	vec3_t n;

    666. 

  666. 	float inv_denom;

    667. 

  667. 

    668. 

  668. 	inv_denom =  DotProduct( normal, normal );

    669. 

  669. #ifndef Q3_VM

    670. 

  670. 	assert( Q_fabs(inv_denom) != 0.0f ); // bk010122 - zero vectors get here

    671. 

  671. #endif

    672. 

  672. 	inv_denom = 1.0f / inv_denom;

    673. 

  673. 

    674. 

  674. 	d = DotProduct( normal, p ) * inv_denom;

    675. 

  675. 

    676. 

  676. 	n[0] = normal[0] * inv_denom;

    677. 

  677. 	n[1] = normal[1] * inv_denom;

    678. 

  678. 	n[2] = normal[2] * inv_denom;

    679. 

  679. 

    680. 

  680. 	dst[0] = p[0] - d * n[0];

    681. 

  681. 	dst[1] = p[1] - d * n[1];

    682. 

  682. 	dst[2] = p[2] - d * n[2];

    683. 

  683. }

    684. 

  684. 

    685. 

  685. /*

    686. 

  686. ================

    687. 

  687. MakeNormalVectors

    688. 

  688. 

    689. 

  689. Given a normalized forward vector, create two

    690. 

  690. other perpendicular vectors

    691. 

  691. ================

    692. 

  692. */

    693. 

  693. void MakeNormalVectors( const vec3_t forward, vec3_t right, vec3_t up) {

    694. 

  694. 	float		d;

    695. 

  695. 

    696. 

  696. 	// this rotate and negate guarantees a vector

    697. 

  697. 	// not colinear with the original

    698. 

  698. 	right[1] = -forward[0];

    699. 

  699. 	right[2] = forward[1];

    700. 

  700. 	right[0] = forward[2];

    701. 

  701. 

    702. 

  702. 	d = DotProduct (right, forward);

    703. 

  703. 	VectorMA (right, -d, forward, right);

    704. 

  704. 	VectorNormalize (right);

    705. 

  705. 	CrossProduct (right, forward, up);

    706. 

  706. }

    707. 

  707. 

    708. 

  708. 

    709. 

  709. void VectorRotate( vec3_t in, vec3_t matrix[3], vec3_t out )

    710. 

  710. {

    711. 

  711. 	out[0] = DotProduct( in, matrix[0] );

    712. 

  712. 	out[1] = DotProduct( in, matrix[1] );

    713. 

  713. 	out[2] = DotProduct( in, matrix[2] );

    714. 

  714. }

    715. 

  715. 

    716. 

  716. //============================================================================

    717. 

  717. 

    718. 

  718. #if !idppc

    719. 

  719. /*

    720. 

  720. ** float q_rsqrt( float number )

    721. 

  721. */

    722. 

  722. float Q_rsqrt( float number )

    723. 

  723. {

    724. 

  724. 	long i;

    725. 

  725. 	float x2, y;

    726. 

  726. 	const float threehalfs = 1.5F;

    727. 

  727. 

    728. 

  728. 	x2 = number * 0.5F;

    729. 

  729. 	y  = number;

    730. 

  730. 	i  = * ( long * ) &y;						// evil floating point bit level hacking

    731. 

  731. 	i  = 0x5f3759df - ( i >> 1 );               // what the fuck?

    732. 

  732. 	y  = * ( float * ) &i;

    733. 

  733. 	y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration

    734. 

  734. //	y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    735. 

  735. 

    736. 

  736. #ifndef Q3_VM

    737. 

  737. #ifdef __linux__

    738. 

  738. 	assert( !isnan(y) ); // bk010122 - FPE?

    739. 

  739. #endif

    740. 

  740. #endif

    741. 

  741. 	return y;

    742. 

  742. }

    743. 

  743. 

    744. 

  744. float Q_fabs( float f ) {

    745. 

  745. 	int tmp = * ( int * ) &f;

    746. 

  746. 	tmp &= 0x7FFFFFFF;

    747. 

  747. 	return * ( float * ) &tmp;

    748. 

  748. }

    749. 

  749. #endif

    750. 

  750. 

    751. 

  751. //============================================================

    752. 

  752. 

    753. 

  753. /*

    754. 

  754. ===============

    755. 

  755. LerpAngle

    756. 

  756. 

    757. 

  757. ===============

    758. 

  758. */

    759. 

  759. float LerpAngle (float from, float to, float frac) {

    760. 

  760. 	float	a;

    761. 

  761. 

    762. 

  762. 	if ( to - from > 180 ) {

    763. 

  763. 		to -= 360;

    764. 

  764. 	}

    765. 

  765. 	if ( to - from < -180 ) {

    766. 

  766. 		to += 360;

    767. 

  767. 	}

    768. 

  768. 	a = from + frac * (to - from);

    769. 

  769. 

    770. 

  770. 	return a;

    771. 

  771. }

    772. 

  772. 

    773. 

  773. 

    774. 

  774. /*

    775. 

  775. =================

    776. 

  776. AngleSubtract

    777. 

  777. 

    778. 

  778. Always returns a value from -180 to 180

    779. 

  779. =================

    780. 

  780. */

    781. 

  781. float	AngleSubtract( float a1, float a2 ) {

    782. 

  782. 	float	a;

    783. 

  783. 

    784. 

  784. 	a = a1 - a2;

    785. 

  785. 	while ( a > 180 ) {

    786. 

  786. 		a -= 360;

    787. 

  787. 	}

    788. 

  788. 	while ( a < -180 ) {

    789. 

  789. 		a += 360;

    790. 

  790. 	}

    791. 

  791. 	return a;

    792. 

  792. }

    793. 

  793. 

    794. 

  794. 

    795. 

  795. void AnglesSubtract( vec3_t v1, vec3_t v2, vec3_t v3 ) {

    796. 

  796. 	v3[0] = AngleSubtract( v1[0], v2[0] );

    797. 

  797. 	v3[1] = AngleSubtract( v1[1], v2[1] );

    798. 

  798. 	v3[2] = AngleSubtract( v1[2], v2[2] );

    799. 

  799. }

    800. 

  800. 

    801. 

  801. 

    802. 

  802. float	AngleMod(float a) {

    803. 

  803. 	a = (360.0/65536) * ((int)(a*(65536/360.0)) & 65535);

    804. 

  804. 	return a;

    805. 

  805. }

    806. 

  806. 

    807. 

  807. 

    808. 

  808. /*

    809. 

  809. =================

    810. 

  810. AngleNormalize360

    811. 

  811. 

    812. 

  812. returns angle normalized to the range [0 <= angle < 360]

    813. 

  813. =================

    814. 

  814. */

    815. 

  815. float AngleNormalize360 ( float angle ) {

    816. 

  816. 	return (360.0 / 65536) * ((int)(angle * (65536 / 360.0)) & 65535);

    817. 

  817. }

    818. 

  818. 

    819. 

  819. 

    820. 

  820. /*

    821. 

  821. =================

    822. 

  822. AngleNormalize180

    823. 

  823. 

    824. 

  824. returns angle normalized to the range [-180 < angle <= 180]

    825. 

  825. =================

    826. 

  826. */

    827. 

  827. float AngleNormalize180 ( float angle ) {

    828. 

  828. 	angle = AngleNormalize360( angle );

    829. 

  829. 	if ( angle > 180.0 ) {

    830. 

  830. 		angle -= 360.0;

    831. 

  831. 	}

    832. 

  832. 	return angle;

    833. 

  833. }

    834. 

  834. 

    835. 

  835. 

    836. 

  836. /*

    837. 

  837. =================

    838. 

  838. AngleDelta

    839. 

  839. 

    840. 

  840. returns the normalized delta from angle1 to angle2

    841. 

  841. =================

    842. 

  842. */

    843. 

  843. float AngleDelta ( float angle1, float angle2 ) {

    844. 

  844. 	return AngleNormalize180( angle1 - angle2 );

    845. 

  845. }

    846. 

  846. 

    847. 

  847. 

    848. 

  848. //============================================================

    849. 

  849. 

    850. 

  850. 

    851. 

  851. /*

    852. 

  852. =================

    853. 

  853. SetPlaneSignbits

    854. 

  854. =================

    855. 

  855. */

    856. 

  856. void SetPlaneSignbits (cplane_t *out) {

    857. 

  857. 	int	bits, j;

    858. 

  858. 

    859. 

  859. 	// for fast box on planeside test

    860. 

  860. 	bits = 0;

    861. 

  861. 	for (j=0 ; j<3 ; j++) {

    862. 

  862. 		if (out->normal[j] < 0) {

    863. 

  863. 			bits |= 1<<j;

    864. 

  864. 		}

    865. 

  865. 	}

    866. 

  866. 	out->signbits = bits;

    867. 

  867. }

    868. 

  868. 

    869. 

  869. 

    870. 

  870. /*

    871. 

  871. ==================

    872. 

  872. BoxOnPlaneSide

    873. 

  873. 

    874. 

  874. Returns 1, 2, or 1 + 2

    875. 

  875. 

    876. 

  876. // this is the slow, general version

    877. 

  877. int BoxOnPlaneSide2 (vec3_t emins, vec3_t emaxs, struct cplane_s *p)

    878. 

  878. {

    879. 

  879. 	int		i;

    880. 

  880. 	float	dist1, dist2;

    881. 

  881. 	int		sides;

    882. 

  882. 	vec3_t	corners[2];

    883. 

  883. 

    884. 

  884. 	for (i=0 ; i<3 ; i++)

    885. 

  885. 	{

    886. 

  886. 		if (p->normal[i] < 0)

    887. 

  887. 		{

    888. 

  888. 			corners[0][i] = emins[i];

    889. 

  889. 			corners[1][i] = emaxs[i];

    890. 

  890. 		}

    891. 

  891. 		else

    892. 

  892. 		{

    893. 

  893. 			corners[1][i] = emins[i];

    894. 

  894. 			corners[0][i] = emaxs[i];

    895. 

  895. 		}

    896. 

  896. 	}

    897. 

  897. 	dist1 = DotProduct (p->normal, corners[0]) - p->dist;

    898. 

  898. 	dist2 = DotProduct (p->normal, corners[1]) - p->dist;

    899. 

  899. 	sides = 0;

    900. 

  900. 	if (dist1 >= 0)

    901. 

  901. 		sides = 1;

    902. 

  902. 	if (dist2 < 0)

    903. 

  903. 		sides |= 2;

    904. 

  904. 

    905. 

  905. 	return sides;

    906. 

  906. }

    907. 

  907. 

    908. 

  908. ==================

    909. 

  909. */

    910. 

  910. 

    911. 

  911. #if !( (defined __linux__ || __FreeBSD__) && (defined __i386__) && (!defined C_ONLY)) // rb010123

    912. 

  912. 

    913. 

  913. #if defined __LCC__ || defined C_ONLY || !id386 || defined __VECTORC

    914. 

  914. 

    915. 

  915. int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)

    916. 

  916. {

    917. 

  917. 	float	dist1, dist2;

    918. 

  918. 	int		sides;

    919. 

  919. 

    920. 

  920. // fast axial cases

    921. 

  921. 	if (p->type < 3)

    922. 

  922. 	{

    923. 

  923. 		if (p->dist <= emins[p->type])

    924. 

  924. 			return 1;

    925. 

  925. 		if (p->dist >= emaxs[p->type])

    926. 

  926. 			return 2;

    927. 

  927. 		return 3;

    928. 

  928. 	}

    929. 

  929. 

    930. 

  930. // general case

    931. 

  931. 	switch (p->signbits)

    932. 

  932. 	{

    933. 

  933. 	case 0:

    934. 

  934. 		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];

    935. 

  935. 		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];

    936. 

  936. 		break;

    937. 

  937. 	case 1:

    938. 

  938. 		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];

    939. 

  939. 		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];

    940. 

  940. 		break;

    941. 

  941. 	case 2:

    942. 

  942. 		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];

    943. 

  943. 		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];

    944. 

  944. 		break;

    945. 

  945. 	case 3:

    946. 

  946. 		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];

    947. 

  947. 		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];

    948. 

  948. 		break;

    949. 

  949. 	case 4:

    950. 

  950. 		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];

    951. 

  951. 		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];

    952. 

  952. 		break;

    953. 

  953. 	case 5:

    954. 

  954. 		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];

    955. 

  955. 		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];

    956. 

  956. 		break;

    957. 

  957. 	case 6:

    958. 

  958. 		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];

    959. 

  959. 		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];

    960. 

  960. 		break;

    961. 

  961. 	case 7:

    962. 

  962. 		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];

    963. 

  963. 		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];

    964. 

  964. 		break;

    965. 

  965. 	default:

    966. 

  966. 		dist1 = dist2 = 0;		// shut up compiler

    967. 

  967. 		break;

    968. 

  968. 	}

    969. 

  969. 

    970. 

  970. 	sides = 0;

    971. 

  971. 	if (dist1 >= p->dist)

    972. 

  972. 		sides = 1;

    973. 

  973. 	if (dist2 < p->dist)

    974. 

  974. 		sides |= 2;

    975. 

  975. 

    976. 

  976. 	return sides;

    977. 

  977. }

    978. 

  978. #else

    979. 

  979. #pragma warning( disable: 4035 )

    980. 

  980. 

    981. 

  981. __declspec( naked ) int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)

    982. 

  982. {

    983. 

  983. 	static int bops_initialized;

    984. 

  984. 	static int Ljmptab[8];

    985. 

  985. 

    986. 

  986. 	__asm {

    987. 

  987. 

    988. 

  988. 		push ebx

    989. 

  989. 			

    990. 

  990. 		cmp bops_initialized, 1

    991. 

  991. 		je  initialized

    992. 

  992. 		mov bops_initialized, 1

    993. 

  993. 		

    994. 

  994. 		mov Ljmptab[0*4], offset Lcase0

    995. 

  995. 		mov Ljmptab[1*4], offset Lcase1

    996. 

  996. 		mov Ljmptab[2*4], offset Lcase2

    997. 

  997. 		mov Ljmptab[3*4], offset Lcase3

    998. 

  998. 		mov Ljmptab[4*4], offset Lcase4

    999. 

  999. 		mov Ljmptab[5*4], offset Lcase5

    1000. 

  1000. 		mov Ljmptab[6*4], offset Lcase6

    1001. 

  1001. 		mov Ljmptab[7*4], offset Lcase7

    1002. 

  1002. 			

    1003. 

  1003. initialized:

    1004. 

  1004. 

    1005. 

  1005. 		mov edx,dword ptr[4+12+esp]

    1006. 

  1006. 		mov ecx,dword ptr[4+4+esp]

    1007. 

  1007. 		xor eax,eax

    1008. 

  1008. 		mov ebx,dword ptr[4+8+esp]

    1009. 

  1009. 		mov al,byte ptr[17+edx]

    1010. 

  1010. 		cmp al,8

    1011. 

  1011. 		jge Lerror

    1012. 

  1012. 		fld dword ptr[0+edx]

    1013. 

  1013. 		fld st(0)

    1014. 

  1014. 		jmp dword ptr[Ljmptab+eax*4]

    1015. 

  1015. Lcase0:

    1016. 

  1016. 		fmul dword ptr[ebx]

    1017. 

  1017. 		fld dword ptr[0+4+edx]

    1018. 

  1018. 		fxch st(2)

    1019. 

  1019. 		fmul dword ptr[ecx]

    1020. 

  1020. 		fxch st(2)

    1021. 

  1021. 		fld st(0)

    1022. 

  1022. 		fmul dword ptr[4+ebx]

    1023. 

  1023. 		fld dword ptr[0+8+edx]

    1024. 

  1024. 		fxch st(2)

    1025. 

  1025. 		fmul dword ptr[4+ecx]

    1026. 

  1026. 		fxch st(2)

    1027. 

  1027. 		fld st(0)

    1028. 

  1028. 		fmul dword ptr[8+ebx]

    1029. 

  1029. 		fxch st(5)

    1030. 

  1030. 		faddp st(3),st(0)

    1031. 

  1031. 		fmul dword ptr[8+ecx]

    1032. 

  1032. 		fxch st(1)

    1033. 

  1033. 		faddp st(3),st(0)

    1034. 

  1034. 		fxch st(3)

    1035. 

  1035. 		faddp st(2),st(0)

    1036. 

  1036. 		jmp LSetSides

    1037. 

  1037. Lcase1:

    1038. 

  1038. 		fmul dword ptr[ecx]

    1039. 

  1039. 		fld dword ptr[0+4+edx]

    1040. 

  1040. 		fxch st(2)

    1041. 

  1041. 		fmul dword ptr[ebx]

    1042. 

  1042. 		fxch st(2)

    1043. 

  1043. 		fld st(0)

    1044. 

  1044. 		fmul dword ptr[4+ebx]

    1045. 

  1045. 		fld dword ptr[0+8+edx]

    1046. 

  1046. 		fxch st(2)

    1047. 

  1047. 		fmul dword ptr[4+ecx]

    1048. 

  1048. 		fxch st(2)

    1049. 

  1049. 		fld st(0)

    1050. 

  1050. 		fmul dword ptr[8+ebx]

    1051. 

  1051. 		fxch st(5)

    1052. 

  1052. 		faddp st(3),st(0)

    1053. 

  1053. 		fmul dword ptr[8+ecx]

    1054. 

  1054. 		fxch st(1)

    1055. 

  1055. 		faddp st(3),st(0)

    1056. 

  1056. 		fxch st(3)

    1057. 

  1057. 		faddp st(2),st(0)

    1058. 

  1058. 		jmp LSetSides

    1059. 

  1059. Lcase2:

    1060. 

  1060. 		fmul dword ptr[ebx]

    1061. 

  1061. 		fld dword ptr[0+4+edx]

    1062. 

  1062. 		fxch st(2)

    1063. 

  1063. 		fmul dword ptr[ecx]

    1064. 

  1064. 		fxch st(2)

    1065. 

  1065. 		fld st(0)

    1066. 

  1066. 		fmul dword ptr[4+ecx]

    1067. 

  1067. 		fld dword ptr[0+8+edx]

    1068. 

  1068. 		fxch st(2)

    1069. 

  1069. 		fmul dword ptr[4+ebx]

    1070. 

  1070. 		fxch st(2)

    1071. 

  1071. 		fld st(0)

    1072. 

  1072. 		fmul dword ptr[8+ebx]

    1073. 

  1073. 		fxch st(5)

    1074. 

  1074. 		faddp st(3),st(0)

    1075. 

  1075. 		fmul dword ptr[8+ecx]

    1076. 

  1076. 		fxch st(1)

    1077. 

  1077. 		faddp st(3),st(0)

    1078. 

  1078. 		fxch st(3)

    1079. 

  1079. 		faddp st(2),st(0)

    1080. 

  1080. 		jmp LSetSides

    1081. 

  1081. Lcase3:

    1082. 

  1082. 		fmul dword ptr[ecx]

    1083. 

  1083. 		fld dword ptr[0+4+edx]

    1084. 

  1084. 		fxch st(2)

    1085. 

  1085. 		fmul dword ptr[ebx]

    1086. 

  1086. 		fxch st(2)

    1087. 

  1087. 		fld st(0)

    1088. 

  1088. 		fmul dword ptr[4+ecx]

    1089. 

  1089. 		fld dword ptr[0+8+edx]

    1090. 

  1090. 		fxch st(2)

    1091. 

  1091. 		fmul dword ptr[4+ebx]

    1092. 

  1092. 		fxch st(2)

    1093. 

  1093. 		fld st(0)

    1094. 

  1094. 		fmul dword ptr[8+ebx]

    1095. 

  1095. 		fxch st(5)

    1096. 

  1096. 		faddp st(3),st(0)

    1097. 

  1097. 		fmul dword ptr[8+ecx]

    1098. 

  1098. 		fxch st(1)

    1099. 

  1099. 		faddp st(3),st(0)

    1100. 

  1100. 		fxch st(3)

    1101. 

  1101. 		faddp st(2),st(0)

    1102. 

  1102. 		jmp LSetSides

    1103. 

  1103. Lcase4:

    1104. 

  1104. 		fmul dword ptr[ebx]

    1105. 

  1105. 		fld dword ptr[0+4+edx]

    1106. 

  1106. 		fxch st(2)

    1107. 

  1107. 		fmul dword ptr[ecx]

    1108. 

  1108. 		fxch st(2)

    1109. 

  1109. 		fld st(0)

    1110. 

  1110. 		fmul dword ptr[4+ebx]

    1111. 

  1111. 		fld dword ptr[0+8+edx]

    1112. 

  1112. 		fxch st(2)

    1113. 

  1113. 		fmul dword ptr[4+ecx]

    1114. 

  1114. 		fxch st(2)

    1115. 

  1115. 		fld st(0)

    1116. 

  1116. 		fmul dword ptr[8+ecx]

    1117. 

  1117. 		fxch st(5)

    1118. 

  1118. 		faddp st(3),st(0)

    1119. 

  1119. 		fmul dword ptr[8+ebx]

    1120. 

  1120. 		fxch st(1)

    1121. 

  1121. 		faddp st(3),st(0)

    1122. 

  1122. 		fxch st(3)

    1123. 

  1123. 		faddp st(2),st(0)

    1124. 

  1124. 		jmp LSetSides

    1125. 

  1125. Lcase5:

    1126. 

  1126. 		fmul dword ptr[ecx]

    1127. 

  1127. 		fld dword ptr[0+4+edx]

    1128. 

  1128. 		fxch st(2)

    1129. 

  1129. 		fmul dword ptr[ebx]

    1130. 

  1130. 		fxch st(2)

    1131. 

  1131. 		fld st(0)

    1132. 

  1132. 		fmul dword ptr[4+ebx]

    1133. 

  1133. 		fld dword ptr[0+8+edx]

    1134. 

  1134. 		fxch st(2)

    1135. 

  1135. 		fmul dword ptr[4+ecx]

    1136. 

  1136. 		fxch st(2)

    1137. 

  1137. 		fld st(0)

    1138. 

  1138. 		fmul dword ptr[8+ecx]

    1139. 

  1139. 		fxch st(5)

    1140. 

  1140. 		faddp st(3),st(0)

    1141. 

  1141. 		fmul dword ptr[8+ebx]

    1142. 

  1142. 		fxch st(1)

    1143. 

  1143. 		faddp st(3),st(0)

    1144. 

  1144. 		fxch st(3)

    1145. 

  1145. 		faddp st(2),st(0)

    1146. 

  1146. 		jmp LSetSides

    1147. 

  1147. Lcase6:

    1148. 

  1148. 		fmul dword ptr[ebx]

    1149. 

  1149. 		fld dword ptr[0+4+edx]

    1150. 

  1150. 		fxch st(2)

    1151. 

  1151. 		fmul dword ptr[ecx]

    1152. 

  1152. 		fxch st(2)

    1153. 

  1153. 		fld st(0)

    1154. 

  1154. 		fmul dword ptr[4+ecx]

    1155. 

  1155. 		fld dword ptr[0+8+edx]

    1156. 

  1156. 		fxch st(2)

    1157. 

  1157. 		fmul dword ptr[4+ebx]

    1158. 

  1158. 		fxch st(2)

    1159. 

  1159. 		fld st(0)

    1160. 

  1160. 		fmul dword ptr[8+ecx]

    1161. 

  1161. 		fxch st(5)

    1162. 

  1162. 		faddp st(3),st(0)

    1163. 

  1163. 		fmul dword ptr[8+ebx]

    1164. 

  1164. 		fxch st(1)

    1165. 

  1165. 		faddp st(3),st(0)

    1166. 

  1166. 		fxch st(3)

    1167. 

  1167. 		faddp st(2),st(0)

    1168. 

  1168. 		jmp LSetSides

    1169. 

  1169. Lcase7:

    1170. 

  1170. 		fmul dword ptr[ecx]

    1171. 

  1171. 		fld dword ptr[0+4+edx]

    1172. 

  1172. 		fxch st(2)

    1173. 

  1173. 		fmul dword ptr[ebx]

    1174. 

  1174. 		fxch st(2)

    1175. 

  1175. 		fld st(0)

    1176. 

  1176. 		fmul dword ptr[4+ecx]

    1177. 

  1177. 		fld dword ptr[0+8+edx]

    1178. 

  1178. 		fxch st(2)

    1179. 

  1179. 		fmul dword ptr[4+ebx]

    1180. 

  1180. 		fxch st(2)

    1181. 

  1181. 		fld st(0)

    1182. 

  1182. 		fmul dword ptr[8+ecx]

    1183. 

  1183. 		fxch st(5)

    1184. 

  1184. 		faddp st(3),st(0)

    1185. 

  1185. 		fmul dword ptr[8+ebx]

    1186. 

  1186. 		fxch st(1)

    1187. 

  1187. 		faddp st(3),st(0)

    1188. 

  1188. 		fxch st(3)

    1189. 

  1189. 		faddp st(2),st(0)

    1190. 

  1190. LSetSides:

    1191. 

  1191. 		faddp st(2),st(0)

    1192. 

  1192. 		fcomp dword ptr[12+edx]

    1193. 

  1193. 		xor ecx,ecx

    1194. 

  1194. 		fnstsw ax

    1195. 

  1195. 		fcomp dword ptr[12+edx]

    1196. 

  1196. 		and ah,1

    1197. 

  1197. 		xor ah,1

    1198. 

  1198. 		add cl,ah

    1199. 

  1199. 		fnstsw ax

    1200. 

  1200. 		and ah,1

    1201. 

  1201. 		add ah,ah

    1202. 

  1202. 		add cl,ah

    1203. 

  1203. 		pop ebx

    1204. 

  1204. 		mov eax,ecx

    1205. 

  1205. 		ret

    1206. 

  1206. Lerror:

    1207. 

  1207. 		int 3

    1208. 

  1208. 	}

    1209. 

  1209. }

    1210. 

  1210. #pragma warning( default: 4035 )

    1211. 

  1211. 

    1212. 

  1212. #endif

    1213. 

  1213. #endif

    1214. 

  1214. 

    1215. 

  1215. /*

    1216. 

  1216. =================

    1217. 

  1217. RadiusFromBounds

    1218. 

  1218. =================

    1219. 

  1219. */

    1220. 

  1220. float RadiusFromBounds( const vec3_t mins, const vec3_t maxs ) {

    1221. 

  1221. 	int		i;

    1222. 

  1222. 	vec3_t	corner;

    1223. 

  1223. 	float	a, b;

    1224. 

  1224. 

    1225. 

  1225. 	for (i=0 ; i<3 ; i++) {

    1226. 

  1226. 		a = fabs( mins[i] );

    1227. 

  1227. 		b = fabs( maxs[i] );

    1228. 

  1228. 		corner[i] = a > b ? a : b;

    1229. 

  1229. 	}

    1230. 

  1230. 

    1231. 

  1231. 	return VectorLength (corner);

    1232. 

  1232. }

    1233. 

  1233. 

    1234. 

  1234. 

    1235. 

  1235. void ClearBounds( vec3_t mins, vec3_t maxs ) {

    1236. 

  1236. 	mins[0] = mins[1] = mins[2] = 99999;

    1237. 

  1237. 	maxs[0] = maxs[1] = maxs[2] = -99999;

    1238. 

  1238. }

    1239. 

  1239. 

    1240. 

  1240. void AddPointToBounds( const vec3_t v, vec3_t mins, vec3_t maxs ) {

    1241. 

  1241. 	if ( v[0] < mins[0] ) {

    1242. 

  1242. 		mins[0] = v[0];

    1243. 

  1243. 	}

    1244. 

  1244. 	if ( v[0] > maxs[0]) {

    1245. 

  1245. 		maxs[0] = v[0];

    1246. 

  1246. 	}

    1247. 

  1247. 

    1248. 

  1248. 	if ( v[1] < mins[1] ) {

    1249. 

  1249. 		mins[1] = v[1];

    1250. 

  1250. 	}

    1251. 

  1251. 	if ( v[1] > maxs[1]) {

    1252. 

  1252. 		maxs[1] = v[1];

    1253. 

  1253. 	}

    1254. 

  1254. 

    1255. 

  1255. 	if ( v[2] < mins[2] ) {

    1256. 

  1256. 		mins[2] = v[2];

    1257. 

  1257. 	}

    1258. 

  1258. 	if ( v[2] > maxs[2]) {

    1259. 

  1259. 		maxs[2] = v[2];

    1260. 

  1260. 	}

    1261. 

  1261. }

    1262. 

  1262. 

    1263. 

  1263. 

    1264. 

  1264. vec_t VectorNormalize( vec3_t v ) {

    1265. 

  1265. 	float	length, ilength;

    1266. 

  1266. 

    1267. 

  1267. 	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];

    1268. 

  1268. 	length = sqrt (length);

    1269. 

  1269. 

    1270. 

  1270. 	if ( length ) {

    1271. 

  1271. 		ilength = 1/length;

    1272. 

  1272. 		v[0] *= ilength;

    1273. 

  1273. 		v[1] *= ilength;

    1274. 

  1274. 		v[2] *= ilength;

    1275. 

  1275. 	}

    1276. 

  1276. 		

    1277. 

  1277. 	return length;

    1278. 

  1278. }

    1279. 

  1279. 

    1280. 

  1280. vec_t VectorNormalize2( const vec3_t v, vec3_t out) {

    1281. 

  1281. 	float	length, ilength;

    1282. 

  1282. 

    1283. 

  1283. 	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];

    1284. 

  1284. 	length = sqrt (length);

    1285. 

  1285. 

    1286. 

  1286. 	if (length)

    1287. 

  1287. 	{

    1288. 

  1288. #ifndef Q3_VM // bk0101022 - FPE related

    1289. 

  1289. //	  assert( ((Q_fabs(v[0])!=0.0f) || (Q_fabs(v[1])!=0.0f) || (Q_fabs(v[2])!=0.0f)) );

    1290. 

  1290. #endif

    1291. 

  1291. 		ilength = 1/length;

    1292. 

  1292. 		out[0] = v[0]*ilength;

    1293. 

  1293. 		out[1] = v[1]*ilength;

    1294. 

  1294. 		out[2] = v[2]*ilength;

    1295. 

  1295. 	} else {

    1296. 

  1296. #ifndef Q3_VM // bk0101022 - FPE related

    1297. 

  1297. //	  assert( ((Q_fabs(v[0])==0.0f) && (Q_fabs(v[1])==0.0f) && (Q_fabs(v[2])==0.0f)) );

    1298. 

  1298. #endif

    1299. 

  1299. 		VectorClear( out );

    1300. 

  1300. 	}

    1301. 

  1301. 		

    1302. 

  1302. 	return length;

    1303. 

  1303. 

    1304. 

  1304. }

    1305. 

  1305. 

    1306. 

  1306. void _VectorMA( const vec3_t veca, float scale, const vec3_t vecb, vec3_t vecc) {

    1307. 

  1307. 	vecc[0] = veca[0] + scale*vecb[0];

    1308. 

  1308. 	vecc[1] = veca[1] + scale*vecb[1];

    1309. 

  1309. 	vecc[2] = veca[2] + scale*vecb[2];

    1310. 

  1310. }

    1311. 

  1311. 

    1312. 

  1312. 

    1313. 

  1313. vec_t _DotProduct( const vec3_t v1, const vec3_t v2 ) {

    1314. 

  1314. 	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];

    1315. 

  1315. }

    1316. 

  1316. 

    1317. 

  1317. void _VectorSubtract( const vec3_t veca, const vec3_t vecb, vec3_t out ) {

    1318. 

  1318. 	out[0] = veca[0]-vecb[0];

    1319. 

  1319. 	out[1] = veca[1]-vecb[1];

    1320. 

  1320. 	out[2] = veca[2]-vecb[2];

    1321. 

  1321. }

    1322. 

  1322. 

    1323. 

  1323. void _VectorAdd( const vec3_t veca, const vec3_t vecb, vec3_t out ) {

    1324. 

  1324. 	out[0] = veca[0]+vecb[0];

    1325. 

  1325. 	out[1] = veca[1]+vecb[1];

    1326. 

  1326. 	out[2] = veca[2]+vecb[2];

    1327. 

  1327. }

    1328. 

  1328. 

    1329. 

  1329. void _VectorCopy( const vec3_t in, vec3_t out ) {

    1330. 

  1330. 	out[0] = in[0];

    1331. 

  1331. 	out[1] = in[1];

    1332. 

  1332. 	out[2] = in[2];

    1333. 

  1333. }

    1334. 

  1334. 

    1335. 

  1335. void _VectorScale( const vec3_t in, vec_t scale, vec3_t out ) {

    1336. 

  1336. 	out[0] = in[0]*scale;

    1337. 

  1337. 	out[1] = in[1]*scale;

    1338. 

  1338. 	out[2] = in[2]*scale;

    1339. 

  1339. }

    1340. 

  1340. 

    1341. 

  1341. void Vector4Scale( const vec4_t in, vec_t scale, vec4_t out ) {

    1342. 

  1342. 	out[0] = in[0]*scale;

    1343. 

  1343. 	out[1] = in[1]*scale;

    1344. 

  1344. 	out[2] = in[2]*scale;

    1345. 

  1345. 	out[3] = in[3]*scale;

    1346. 

  1346. }

    1347. 

  1347. 

    1348. 

  1348. 

    1349. 

  1349. int Q_log2( int val ) {

    1350. 

  1350. 	int answer;

    1351. 

  1351. 

    1352. 

  1352. 	answer = 0;

    1353. 

  1353. 	while ( ( val>>=1 ) != 0 ) {

    1354. 

  1354. 		answer++;

    1355. 

  1355. 	}

    1356. 

  1356. 	return answer;

    1357. 

  1357. }

    1358. 

  1358. 

    1359. 

  1359. 

    1360. 

  1360. 

    1361. 

  1361. /*

    1362. 

  1362. =================

    1363. 

  1363. PlaneTypeForNormal

    1364. 

  1364. =================

    1365. 

  1365. */

    1366. 

  1366. /*

    1367. 

  1367. int	PlaneTypeForNormal (vec3_t normal) {

    1368. 

  1368. 	if ( normal[0] == 1.0 )

    1369. 

  1369. 		return PLANE_X;

    1370. 

  1370. 	if ( normal[1] == 1.0 )

    1371. 

  1371. 		return PLANE_Y;

    1372. 

  1372. 	if ( normal[2] == 1.0 )

    1373. 

  1373. 		return PLANE_Z;

    1374. 

  1374. 	

    1375. 

  1375. 	return PLANE_NON_AXIAL;

    1376. 

  1376. }

    1377. 

  1377. */

    1378. 

  1378. 

    1379. 

  1379. 

    1380. 

  1380. /*

    1381. 

  1381. ================

    1382. 

  1382. MatrixMultiply

    1383. 

  1383. ================

    1384. 

  1384. */

    1385. 

  1385. void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]) {

    1386. 

  1386. 	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +

    1387. 

  1387. 				in1[0][2] * in2[2][0];

    1388. 

  1388. 	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +

    1389. 

  1389. 				in1[0][2] * in2[2][1];

    1390. 

  1390. 	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +

    1391. 

  1391. 				in1[0][2] * in2[2][2];

    1392. 

  1392. 	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +

    1393. 

  1393. 				in1[1][2] * in2[2][0];

    1394. 

  1394. 	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +

    1395. 

  1395. 				in1[1][2] * in2[2][1];

    1396. 

  1396. 	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +

    1397. 

  1397. 				in1[1][2] * in2[2][2];

    1398. 

  1398. 	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +

    1399. 

  1399. 				in1[2][2] * in2[2][0];

    1400. 

  1400. 	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +

    1401. 

  1401. 				in1[2][2] * in2[2][1];

    1402. 

  1402. 	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +

    1403. 

  1403. 				in1[2][2] * in2[2][2];

    1404. 

  1404. }

    1405. 

  1405. 

    1406. 

  1406. 

    1407. 

  1407. void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up) {

    1408. 

  1408. 	float		angle;

    1409. 

  1409. 	static float		sr, sp, sy, cr, cp, cy;

    1410. 

  1410. 	// static to help MS compiler fp bugs

    1411. 

  1411. 

    1412. 

  1412. 	angle = angles[YAW] * (M_PI*2 / 360);

    1413. 

  1413. 	sy = sin(angle);

    1414. 

  1414. 	cy = cos(angle);

    1415. 

  1415. 	angle = angles[PITCH] * (M_PI*2 / 360);

    1416. 

  1416. 	sp = sin(angle);

    1417. 

  1417. 	cp = cos(angle);

    1418. 

  1418. 	angle = angles[ROLL] * (M_PI*2 / 360);

    1419. 

  1419. 	sr = sin(angle);

    1420. 

  1420. 	cr = cos(angle);

    1421. 

  1421. 

    1422. 

  1422. 	if (forward)

    1423. 

  1423. 	{

    1424. 

  1424. 		forward[0] = cp*cy;

    1425. 

  1425. 		forward[1] = cp*sy;

    1426. 

  1426. 		forward[2] = -sp;

    1427. 

  1427. 	}

    1428. 

  1428. 	if (right)

    1429. 

  1429. 	{

    1430. 

  1430. 		right[0] = (-1*sr*sp*cy+-1*cr*-sy);

    1431. 

  1431. 		right[1] = (-1*sr*sp*sy+-1*cr*cy);

    1432. 

  1432. 		right[2] = -1*sr*cp;

    1433. 

  1433. 	}

    1434. 

  1434. 	if (up)

    1435. 

  1435. 	{

    1436. 

  1436. 		up[0] = (cr*sp*cy+-sr*-sy);

    1437. 

  1437. 		up[1] = (cr*sp*sy+-sr*cy);

    1438. 

  1438. 		up[2] = cr*cp;

    1439. 

  1439. 	}

    1440. 

  1440. }

    1441. 

  1441. 

    1442. 

  1442. /*

    1443. 

  1443. ** assumes "src" is normalized

    1444. 

  1444. */

    1445. 

  1445. void PerpendicularVector( vec3_t dst, const vec3_t src )

    1446. 

  1446. {

    1447. 

  1447. 	int	pos;

    1448. 

  1448. 	int i;

    1449. 

  1449. 	float minelem = 1.0F;

    1450. 

  1450. 	vec3_t tempvec;

    1451. 

  1451. 

    1452. 

  1452. 	/*

    1453. 

  1453. 	** find the smallest magnitude axially aligned vector

    1454. 

  1454. 	*/

    1455. 

  1455. 	for ( pos = 0, i = 0; i < 3; i++ )

    1456. 

  1456. 	{

    1457. 

  1457. 		if ( fabs( src[i] ) < minelem )

    1458. 

  1458. 		{

    1459. 

  1459. 			pos = i;

    1460. 

  1460. 			minelem = fabs( src[i] );

    1461. 

  1461. 		}

    1462. 

  1462. 	}

    1463. 

  1463. 	tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;

    1464. 

  1464. 	tempvec[pos] = 1.0F;

    1465. 

  1465. 

    1466. 

  1466. 	/*

    1467. 

  1467. 	** project the point onto the plane defined by src

    1468. 

  1468. 	*/

    1469. 

  1469. 	ProjectPointOnPlane( dst, tempvec, src );

    1470. 

  1470. 

    1471. 

  1471. 	/*

    1472. 

  1472. 	** normalize the result

    1473. 

  1473. 	*/

    1474. 

  1474. 	VectorNormalize( dst );

    1475. 

  1475. }

    1476. 

  1476. 

    1477. 

  1477. 

    1478. 

  1478.