PageRenderTime 74ms CodeModel.GetById 37ms RepoModel.GetById 0ms app.codeStats 0ms

/game/q_shared.c

https://github.com/hifi-unmaintained/aprq2
C | 1687 lines | 1243 code | 224 blank | 220 comment | 268 complexity | 058d3eac0dede550cef530510d97d135 MD5 | raw file
    

  1. /*

    2. 

  2. Copyright (C) 1997-2001 Id Software, Inc.

    3. 

  3. 

    4. 

  4. This program is free software; you can redistribute it and/or

    5. 

  5. modify it under the terms of the GNU General Public License

    6. 

  6. as published by the Free Software Foundation; either version 2

    7. 

  7. of the License, or (at your option) any later version.

    8. 

  8. 

    9. 

  9. This program is distributed in the hope that it will be useful,

    10. 

  10. but WITHOUT ANY WARRANTY; without even the implied warranty of

    11. 

  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

    12. 

  12. 

    13. 

  13. See the GNU General Public License for more details.

    14. 

  14. 

    15. 

  15. You should have received a copy of the GNU General Public License

    16. 

  16. along with this program; if not, write to the Free Software

    17. 

  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    18. 

  18. 

    19. 

  19. */

    20. 

  20. 

    21. 

  21. #include "q_shared.h"

    22. 

  22. 

    23. 

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

    24. 

  24. 

    25. 

  25. const vec3_t bytedirs[NUMVERTEXNORMALS] =

    26. 

  26. {

    27. 

  27. #include "../client/anorms.h"

    28. 

  28. };

    29. 

  29. 

    30. 

  30. int DirToByte( const vec3_t dir )

    31. 

  31. {

    32. 

  32. 	int		i, best = 0;

    33. 

  33. 	float	d, bestd = 0.0f;

    34. 

  34. 

    35. 

  35. 	if (!dir)

    36. 

  36. 		return 0;

    37. 

  37. 

    38. 

  38. 	for( i = 0; i < NUMVERTEXNORMALS; i++ ) {

    39. 

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

    40. 

  40. 		if( d > bestd ) {

    41. 

  41. 			bestd = d;

    42. 

  42. 			best = i;

    43. 

  43. 		}

    44. 

  44. 	}

    45. 

  45. 

    46. 

  46. 	return best;

    47. 

  47. }

    48. 

  48. 

    49. 

  49. void ByteToDir (int b, vec3_t dir)

    50. 

  50. {

    51. 

  51. 	if ((unsigned)b >= NUMVERTEXNORMALS)

    52. 

  52. 		VectorClear(dir);

    53. 

  53. 	else

    54. 

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

    55. 

  55. }

    56. 

  56. 

    57. 

  57. //============================================================================

    58. 

  58. 

    59. 

  59. void MakeNormalVectors (const vec3_t forward, vec3_t right, vec3_t up)

    60. 

  60. {

    61. 

  61. 	float		d;

    62. 

  62. 

    63. 

  63. 	// this rotate and negat guarantees a vector

    64. 

  64. 	// not colinear with the original

    65. 

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

    66. 

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

    67. 

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

    68. 

  68. 

    69. 

  69. 	d = DotProduct (right, forward);

    70. 

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

    71. 

  71. 	VectorNormalize (right);

    72. 

  72. 	CrossProduct (right, forward, up);

    73. 

  73. }

    74. 

  74. 

    75. 

  75. void Q_sincos( float angle, float *s, float *c )
    76. 

  76. {
    77. 

  77. #ifdef _WIN32
    78. 

  78. 	_asm {
    79. 

  79. 		fld		angle
    80. 

  80. 		fsincos
    81. 

  81. 		mov		ecx, c
    82. 

  82. 		mov		edx, s
    83. 

  83. 		fstp	dword ptr [ecx]
    84. 

  84. 		fstp	dword ptr [edx]
    85. 

  85. 	}
    86. 

  86. #else
    87. 

  87. 	*s = (float)sin( angle );
    88. 

  88. 	*c = (float)cos( angle );
    89. 

  89. #endif
    90. 

  90. }

    91. 

  91. 

    92. 

  92. void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees )

    93. 

  93. {

    94. 

  94. 	float		t0, t1, c, s;

    95. 

  95. 	vec3_t		vr, vu, vf;

    96. 

  96. 

    97. 

  97. 	Q_sincos(DEG2RAD(degrees), &s, &c);

    98. 

  98. 

    99. 

  99. 	VectorCopy (dir, vf);

    100. 

  100. 	MakeNormalVectors (vf, vr, vu);

    101. 

  101. 

    102. 

  102. 	t0 = vr[0] * c + vu[0] * -s;

    103. 

  103. 	t1 = vr[0] * s + vu[0] *  c;

    104. 

  104. 	dst[0] = (t0 * vr[0] + t1 * vu[0] + vf[0] * vf[0]) * point[0]

    105. 

  105. 		   + (t0 * vr[1] + t1 * vu[1] + vf[0] * vf[1]) * point[1]

    106. 

  106. 		   + (t0 * vr[2] + t1 * vu[2] + vf[0] * vf[2]) * point[2];

    107. 

  107. 

    108. 

  108. 	t0 = vr[1] * c + vu[1] * -s;

    109. 

  109. 	t1 = vr[1] * s + vu[1] *  c;

    110. 

  110. 	dst[1] = (t0 * vr[0] + t1 * vu[0] + vf[1] * vf[0]) * point[0]

    111. 

  111. 		   + (t0 * vr[1] + t1 * vu[1] + vf[1] * vf[1]) * point[1]

    112. 

  112. 		   + (t0 * vr[2] + t1 * vu[2] + vf[1] * vf[2]) * point[2];

    113. 

  113. 

    114. 

  114. 	t0 = vr[2] * c + vu[2] * -s;

    115. 

  115. 	t1 = vr[2] * s + vu[2] *  c;

    116. 

  116. 	dst[2] = (t0 * vr[0] + t1 * vu[0] + vf[2] * vf[0]) * point[0]

    117. 

  117. 		   + (t0 * vr[1] + t1 * vu[1] + vf[2] * vf[1]) * point[1]

    118. 

  118. 		   + (t0 * vr[2] + t1 * vu[2] + vf[2] * vf[2]) * point[2];

    119. 

  119. }

    120. 

  120. 

    121. 

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

    122. 

  122. {

    123. 

  123. 	float sr, sp, sy, cr, cp, cy, t;

    124. 

  124. 

    125. 

  125. 	Q_sincos(DEG2RAD(angles[YAW]), &sy, &cy);

    126. 

  126. 	Q_sincos(DEG2RAD(angles[PITCH]), &sp, &cp);

    127. 

  127. 

    128. 

  128. 	if (forward)

    129. 

  129. 	{

    130. 

  130. 		forward[0] = cp * cy;

    131. 

  131. 		forward[1] = cp * sy;

    132. 

  132. 		forward[2] = -sp;

    133. 

  133. 	}

    134. 

  134. 

    135. 

  135. 	if (right) {

    136. 

  136. 		Q_sincos(DEG2RAD(angles[ROLL]), &sr, &cr);

    137. 

  137. 

    138. 

  138. 		t = sr*sp;

    139. 

  139. 		right[0] = -t*cy+cr*sy;

    140. 

  140. 		right[1] = -t*sy-cr*cy;

    141. 

  141. 		right[2] = -sr*cp;

    142. 

  142. 

    143. 

  143. 		if (up) {

    144. 

  144. 			t = cr*sp;

    145. 

  145. 			up[0] = t*cy+sr*sy;

    146. 

  146. 			up[1] = t*sy-sr*cy;

    147. 

  147. 			up[2] = cr*cp;

    148. 

  148. 		}

    149. 

  149. 	}

    150. 

  150. 	else if (up) {

    151. 

  151. 		Q_sincos(DEG2RAD(angles[ROLL]), &sr, &cr);

    152. 

  152. 

    153. 

  153. 		t = cr*sp;

    154. 

  154. 		up[0] = t*cy+sr*sy;

    155. 

  155. 		up[1] = t*sy-sr*cy;

    156. 

  156. 		up[2] = cr*cp;

    157. 

  157. 	}

    158. 

  158. }

    159. 

  159. 

    160. 

  160. void VecToAngles (const vec3_t vec, vec3_t angles)

    161. 

  161. {

    162. 

  162. 	float	forward, yaw, pitch;

    163. 

  163. 	

    164. 

  164. 	if (vec[1] == 0 && vec[0] == 0)

    165. 

  165. 	{

    166. 

  166. 		yaw = 0;

    167. 

  167. 		if (vec[2] > 0)

    168. 

  168. 			pitch = 90;

    169. 

  169. 		else

    170. 

  170. 			pitch = 270;

    171. 

  171. 	}

    172. 

  172. 	else

    173. 

  173. 	{

    174. 

  174. 		if (vec[0]) {

    175. 

  175. 			yaw = RAD2DEG( (float)atan2(vec[1], vec[0]) );

    176. 

  176. 			if (yaw < 0)

    177. 

  177. 				yaw += 360;

    178. 

  178. 		} else if (vec[1] > 0) {

    179. 

  179. 			yaw = 90;

    180. 

  180. 		} else {

    181. 

  181. 			yaw = 270;

    182. 

  182. 		}

    183. 

  183. 

    184. 

  184. 		forward = (float)sqrt(vec[0]*vec[0] + vec[1]*vec[1]);

    185. 

  185. 		pitch = RAD2DEG((float)atan2(vec[2], forward));

    186. 

  186. 		if (pitch < 0)

    187. 

  187. 			pitch += 360;

    188. 

  188. 	}

    189. 

  189. 

    190. 

  190. 	angles[PITCH] = -pitch;

    191. 

  191. 	angles[YAW] = yaw;

    192. 

  192. 	angles[ROLL] = 0;

    193. 

  193. }

    194. 

  194. 

    195. 

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

    196. 

  196. {

    197. 

  197. 	float	sp, sy, sr, cp, cy, cr, t;

    198. 

  198. 

    199. 

  199. 	Q_sincos(DEG2RAD(angles[YAW]), &sy, &cy);

    200. 

  200. 	Q_sincos(DEG2RAD(angles[PITCH]), &sp, &cp);

    201. 

  201. 	Q_sincos(DEG2RAD(angles[ROLL]), &sr, &cr);

    202. 

  202. 

    203. 

  203. 	axis[0][0] = cp*cy;

    204. 

  204. 	axis[0][1] = cp*sy;

    205. 

  205. 	axis[0][2] = -sp;

    206. 

  206. 	t = sr*sp;

    207. 

  207. 	axis[1][0] = t*cy+cr*-sy;

    208. 

  208. 	axis[1][1] = t*sy+cr*cy;

    209. 

  209. 	axis[1][2] = sr*cp;

    210. 

  210. 	t = cr*sp;

    211. 

  211. 	axis[2][0] = t*cy+sr*sy;

    212. 

  212. 	axis[2][1] = t*sy-sr*cy;

    213. 

  213. 	axis[2][2] = cr*cp;

    214. 

  214. }

    215. 

  215. 

    216. 

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

    217. 

  217. {

    218. 

  218. 	float d;

    219. 

  219. 

    220. 

  220. 	d = 1.0f / DotProduct( normal, normal );

    221. 

  221. 

    222. 

  222. 	d = DotProduct( normal, p ) * d * d;

    223. 

  223. 

    224. 

  224. 	dst[0] = p[0] - d * normal[0];

    225. 

  225. 	dst[1] = p[1] - d * normal[1];

    226. 

  226. 	dst[2] = p[2] - d * normal[2];

    227. 

  227. }

    228. 

  228. 

    229. 

  229. /*

    230. 

  230. ** assumes "src" is normalized

    231. 

  231. */

    232. 

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

    233. 

  233. {

    234. 

  234. 	if (!src[0]) {

    235. 

  235. 		VectorSet(dst, 1, 0, 0);

    236. 

  236. 	} else if (!src[1]) {

    237. 

  237. 		VectorSet(dst, 0, 1, 0);

    238. 

  238. 	} else if (!src[2]) {

    239. 

  239. 		VectorSet(dst, 0, 0, 1);

    240. 

  240. 	} else {

    241. 

  241. 		VectorSet(dst, -src[1], src[0], 0);

    242. 

  242. 		VectorNormalize(dst);

    243. 

  243. 	}

    244. 

  244. }

    245. 

  245. 

    246. 

  246. /*

    247. 

  247. ================

    248. 

  248. R_ConcatRotations

    249. 

  249. ================

    250. 

  250. */

    251. 

  251. void R_ConcatRotations (float in1[3][3], float in2[3][3], float out[3][3])

    252. 

  252. {

    253. 

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

    254. 

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

    255. 

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

    256. 

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

    257. 

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

    258. 

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

    259. 

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

    260. 

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

    261. 

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

    262. 

  262. }

    263. 

  263. 

    264. 

  264. /*

    265. 

  265. ================

    266. 

  266. R_ConcatTransforms

    267. 

  267. ================

    268. 

  268. */

    269. 

  269. void R_ConcatTransforms (float in1[3][4], float in2[3][4], float out[3][4])

    270. 

  270. {

    271. 

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

    272. 

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

    273. 

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

    274. 

  274. 	out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] +	in1[0][2] * in2[2][3] + in1[0][3];

    275. 

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

    276. 

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

    277. 

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

    278. 

  278. 	out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] +	in1[1][2] * in2[2][3] + in1[1][3];

    279. 

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

    280. 

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

    281. 

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

    282. 

  282. 	out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] +	in1[2][2] * in2[2][3] + in1[2][3];

    283. 

  283. }

    284. 

  284. 

    285. 

  285. 

    286. 

  286. //============================================================================

    287. 

  287. 

    288. 

  288. 

    289. 

  289. float Q_fabs (float f)

    290. 

  290. {

    291. 

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

    292. 

  292. 	tmp &= 0x7FFFFFFF;

    293. 

  293. 	return * ( float * ) &tmp;

    294. 

  294. }

    295. 

  295. 

    296. 

  296. #if defined _M_IX86 && !defined C_ONLY

    297. 

  297. #pragma warning (disable:4035)

    298. 

  298. __declspec( naked ) long Q_ftol( float f )

    299. 

  299. {

    300. 

  300. 	static int tmp;

    301. 

  301. 	__asm {

    302. 

  302. 		fld dword ptr [esp+4]

    303. 

  303. 		fistp tmp

    304. 

  304. 		mov eax, tmp

    305. 

  305. 		ret

    306. 

  306. 	}

    307. 

  307. }

    308. 

  308. #pragma warning (default:4035)

    309. 

  309. #endif

    310. 

  310. 

    311. 

  311. float Q_RSqrt (float number)

    312. 

  312. {

    313. 

  313. 	float	y;

    314. 

  314. 

    315. 

  315. 	if (number == 0.0f)

    316. 

  316. 		return 0.0f;

    317. 

  317. 	*((int *)&y) = 0x5f3759df - ((* (int *) &number) >> 1);

    318. 

  318. 	return y * (1.5f - number * 0.5f * y * y);

    319. 

  319. }

    320. 

  320. 

    321. 

  321. /*

    322. 

  322. ===============

    323. 

  323. LerpAngle

    324. 

  324. 

    325. 

  325. ===============

    326. 

  326. */

    327. 

  327. float LerpAngle (float a2, float a1, float frac)

    328. 

  328. {

    329. 

  329. 	if (a1 - a2 > 180)

    330. 

  330. 		a1 -= 360;

    331. 

  331. 	else if (a1 - a2 < -180)

    332. 

  332. 		a1 += 360;

    333. 

  333. 

    334. 

  334. 	return a2 + frac * (a1 - a2);

    335. 

  335. }

    336. 

  336. 

    337. 

  337. /*

    338. 

  338. ====================

    339. 

  339. CalcFov

    340. 

  340. ====================

    341. 

  341. */

    342. 

  342. float CalcFov (float fov_x, float width, float height)

    343. 

  343. {

    344. 

  344. 	if (fov_x < 1 || fov_x > 179)

    345. 

  345. 		Com_Error (ERR_DROP, "Bad fov: %f", fov_x);

    346. 

  346. 

    347. 

  347. 	width = width/(float)tan(fov_x/360*M_PI);

    348. 

  348. 

    349. 

  349. 	return (float)atan2(height, width)*360/M_PI;

    350. 

  350. }

    351. 

  351. 

    352. 

  352. /*

    353. 

  353. ==================

    354. 

  354. BoxOnPlaneSide

    355. 

  355. 

    356. 

  356. Returns 1, 2, or 1 + 2

    357. 

  357. ==================

    358. 

  358. */

    359. 

  359. #if !id386 || defined(C_ONLY) || defined(__linux__) || defined(__FreeBSD__)

    360. 

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

    361. 

  361. {

    362. 

  362. 	//the following optimisation is performed by BOX_ON_PLANE_SIDE macro

    363. 

  363. 	//if (p->type < 3)

    364. 

  364. 	//	return ((emaxs[p->type] >= p->dist) | ((emins[p->type] < p->dist) << 1));

    365. 

  365. 	switch(p->signbits) {

    366. 

  366. 	default:

    367. 

  367. 	case 0:

    368. 

  368. 		return	(((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) >= p->dist) |

    369. 

  369. 				(((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) < p->dist) << 1));

    370. 

  370. 	case 1:

    371. 

  371. 		return	(((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) >= p->dist) |

    372. 

  372. 				(((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) < p->dist) << 1));

    373. 

  373. 	case 2:

    374. 

  374. 		return	(((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) >= p->dist) |

    375. 

  375. 				(((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) < p->dist) << 1));

    376. 

  376. 	case 3:

    377. 

  377. 		return	(((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) >= p->dist) |

    378. 

  378. 				(((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) < p->dist) << 1));

    379. 

  379. 	case 4:

    380. 

  380. 		return	(((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) >= p->dist) |

    381. 

  381. 				(((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));

    382. 

  382. 	case 5:

    383. 

  383. 		return	(((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emins[2]) >= p->dist) |

    384. 

  384. 				(((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));

    385. 

  385. 	case 6:

    386. 

  386. 		return	(((p->normal[0] * emaxs[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) >= p->dist) |

    387. 

  387. 				(((p->normal[0] * emins[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));

    388. 

  388. 	case 7:

    389. 

  389. 		return	(((p->normal[0] * emins[0] + p->normal[1] * emins[1] + p->normal[2] * emins[2]) >= p->dist) |

    390. 

  390. 				(((p->normal[0] * emaxs[0] + p->normal[1] * emaxs[1] + p->normal[2] * emaxs[2]) < p->dist) << 1));

    391. 

  391. 	}

    392. 

  392. }

    393. 

  393. #else

    394. 

  394. #pragma warning( disable: 4035 )

    395. 

  395. 

    396. 

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

    397. 

  397. {

    398. 

  398. 	static int bops_initialized;

    399. 

  399. 	static int Ljmptab[8];

    400. 

  400. 

    401. 

  401. 	__asm {

    402. 

  402. 

    403. 

  403. 		push ebx

    404. 

  404. 			

    405. 

  405. 		cmp bops_initialized, 1

    406. 

  406. 		je  initialized

    407. 

  407. 		mov bops_initialized, 1

    408. 

  408. 		

    409. 

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

    410. 

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

    411. 

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

    412. 

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

    413. 

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

    414. 

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

    415. 

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

    416. 

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

    417. 

  417. 			

    418. 

  418. initialized:

    419. 

  419. 

    420. 

  420. 		mov edx,ds:dword ptr[4+12+esp]

    421. 

  421. 		mov ecx,ds:dword ptr[4+4+esp]

    422. 

  422. 		xor eax,eax

    423. 

  423. 		mov ebx,ds:dword ptr[4+8+esp]

    424. 

  424. 		mov al,ds:byte ptr[17+edx]

    425. 

  425. 		cmp al,8

    426. 

  426. 		jge Lerror

    427. 

  427. 		fld ds:dword ptr[0+edx]

    428. 

  428. 		fld st(0)

    429. 

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

    430. 

  430. Lcase0:

    431. 

  431. 		fmul ds:dword ptr[ebx]

    432. 

  432. 		fld ds:dword ptr[0+4+edx]

    433. 

  433. 		fxch st(2)

    434. 

  434. 		fmul ds:dword ptr[ecx]

    435. 

  435. 		fxch st(2)

    436. 

  436. 		fld st(0)

    437. 

  437. 		fmul ds:dword ptr[4+ebx]

    438. 

  438. 		fld ds:dword ptr[0+8+edx]

    439. 

  439. 		fxch st(2)

    440. 

  440. 		fmul ds:dword ptr[4+ecx]

    441. 

  441. 		fxch st(2)

    442. 

  442. 		fld st(0)

    443. 

  443. 		fmul ds:dword ptr[8+ebx]

    444. 

  444. 		fxch st(5)

    445. 

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

    446. 

  446. 		fmul ds:dword ptr[8+ecx]

    447. 

  447. 		fxch st(1)

    448. 

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

    449. 

  449. 		fxch st(3)

    450. 

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

    451. 

  451. 		jmp LSetSides

    452. 

  452. Lcase1:

    453. 

  453. 		fmul ds:dword ptr[ecx]

    454. 

  454. 		fld ds:dword ptr[0+4+edx]

    455. 

  455. 		fxch st(2)

    456. 

  456. 		fmul ds:dword ptr[ebx]

    457. 

  457. 		fxch st(2)

    458. 

  458. 		fld st(0)

    459. 

  459. 		fmul ds:dword ptr[4+ebx]

    460. 

  460. 		fld ds:dword ptr[0+8+edx]

    461. 

  461. 		fxch st(2)

    462. 

  462. 		fmul ds:dword ptr[4+ecx]

    463. 

  463. 		fxch st(2)

    464. 

  464. 		fld st(0)

    465. 

  465. 		fmul ds:dword ptr[8+ebx]

    466. 

  466. 		fxch st(5)

    467. 

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

    468. 

  468. 		fmul ds:dword ptr[8+ecx]

    469. 

  469. 		fxch st(1)

    470. 

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

    471. 

  471. 		fxch st(3)

    472. 

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

    473. 

  473. 		jmp LSetSides

    474. 

  474. Lcase2:

    475. 

  475. 		fmul ds:dword ptr[ebx]

    476. 

  476. 		fld ds:dword ptr[0+4+edx]

    477. 

  477. 		fxch st(2)

    478. 

  478. 		fmul ds:dword ptr[ecx]

    479. 

  479. 		fxch st(2)

    480. 

  480. 		fld st(0)

    481. 

  481. 		fmul ds:dword ptr[4+ecx]

    482. 

  482. 		fld ds:dword ptr[0+8+edx]

    483. 

  483. 		fxch st(2)

    484. 

  484. 		fmul ds:dword ptr[4+ebx]

    485. 

  485. 		fxch st(2)

    486. 

  486. 		fld st(0)

    487. 

  487. 		fmul ds:dword ptr[8+ebx]

    488. 

  488. 		fxch st(5)

    489. 

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

    490. 

  490. 		fmul ds:dword ptr[8+ecx]

    491. 

  491. 		fxch st(1)

    492. 

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

    493. 

  493. 		fxch st(3)

    494. 

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

    495. 

  495. 		jmp LSetSides

    496. 

  496. Lcase3:

    497. 

  497. 		fmul ds:dword ptr[ecx]

    498. 

  498. 		fld ds:dword ptr[0+4+edx]

    499. 

  499. 		fxch st(2)

    500. 

  500. 		fmul ds:dword ptr[ebx]

    501. 

  501. 		fxch st(2)

    502. 

  502. 		fld st(0)

    503. 

  503. 		fmul ds:dword ptr[4+ecx]

    504. 

  504. 		fld ds:dword ptr[0+8+edx]

    505. 

  505. 		fxch st(2)

    506. 

  506. 		fmul ds:dword ptr[4+ebx]

    507. 

  507. 		fxch st(2)

    508. 

  508. 		fld st(0)

    509. 

  509. 		fmul ds:dword ptr[8+ebx]

    510. 

  510. 		fxch st(5)

    511. 

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

    512. 

  512. 		fmul ds:dword ptr[8+ecx]

    513. 

  513. 		fxch st(1)

    514. 

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

    515. 

  515. 		fxch st(3)

    516. 

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

    517. 

  517. 		jmp LSetSides

    518. 

  518. Lcase4:

    519. 

  519. 		fmul ds:dword ptr[ebx]

    520. 

  520. 		fld ds:dword ptr[0+4+edx]

    521. 

  521. 		fxch st(2)

    522. 

  522. 		fmul ds:dword ptr[ecx]

    523. 

  523. 		fxch st(2)

    524. 

  524. 		fld st(0)

    525. 

  525. 		fmul ds:dword ptr[4+ebx]

    526. 

  526. 		fld ds:dword ptr[0+8+edx]

    527. 

  527. 		fxch st(2)

    528. 

  528. 		fmul ds:dword ptr[4+ecx]

    529. 

  529. 		fxch st(2)

    530. 

  530. 		fld st(0)

    531. 

  531. 		fmul ds:dword ptr[8+ecx]

    532. 

  532. 		fxch st(5)

    533. 

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

    534. 

  534. 		fmul ds:dword ptr[8+ebx]

    535. 

  535. 		fxch st(1)

    536. 

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

    537. 

  537. 		fxch st(3)

    538. 

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

    539. 

  539. 		jmp LSetSides

    540. 

  540. Lcase5:

    541. 

  541. 		fmul ds:dword ptr[ecx]

    542. 

  542. 		fld ds:dword ptr[0+4+edx]

    543. 

  543. 		fxch st(2)

    544. 

  544. 		fmul ds:dword ptr[ebx]

    545. 

  545. 		fxch st(2)

    546. 

  546. 		fld st(0)

    547. 

  547. 		fmul ds:dword ptr[4+ebx]

    548. 

  548. 		fld ds:dword ptr[0+8+edx]

    549. 

  549. 		fxch st(2)

    550. 

  550. 		fmul ds:dword ptr[4+ecx]

    551. 

  551. 		fxch st(2)

    552. 

  552. 		fld st(0)

    553. 

  553. 		fmul ds:dword ptr[8+ecx]

    554. 

  554. 		fxch st(5)

    555. 

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

    556. 

  556. 		fmul ds:dword ptr[8+ebx]

    557. 

  557. 		fxch st(1)

    558. 

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

    559. 

  559. 		fxch st(3)

    560. 

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

    561. 

  561. 		jmp LSetSides

    562. 

  562. Lcase6:

    563. 

  563. 		fmul ds:dword ptr[ebx]

    564. 

  564. 		fld ds:dword ptr[0+4+edx]

    565. 

  565. 		fxch st(2)

    566. 

  566. 		fmul ds:dword ptr[ecx]

    567. 

  567. 		fxch st(2)

    568. 

  568. 		fld st(0)

    569. 

  569. 		fmul ds:dword ptr[4+ecx]

    570. 

  570. 		fld ds:dword ptr[0+8+edx]

    571. 

  571. 		fxch st(2)

    572. 

  572. 		fmul ds:dword ptr[4+ebx]

    573. 

  573. 		fxch st(2)

    574. 

  574. 		fld st(0)

    575. 

  575. 		fmul ds:dword ptr[8+ecx]

    576. 

  576. 		fxch st(5)

    577. 

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

    578. 

  578. 		fmul ds:dword ptr[8+ebx]

    579. 

  579. 		fxch st(1)

    580. 

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

    581. 

  581. 		fxch st(3)

    582. 

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

    583. 

  583. 		jmp LSetSides

    584. 

  584. Lcase7:

    585. 

  585. 		fmul ds:dword ptr[ecx]

    586. 

  586. 		fld ds:dword ptr[0+4+edx]

    587. 

  587. 		fxch st(2)

    588. 

  588. 		fmul ds:dword ptr[ebx]

    589. 

  589. 		fxch st(2)

    590. 

  590. 		fld st(0)

    591. 

  591. 		fmul ds:dword ptr[4+ecx]

    592. 

  592. 		fld ds:dword ptr[0+8+edx]

    593. 

  593. 		fxch st(2)

    594. 

  594. 		fmul ds:dword ptr[4+ebx]

    595. 

  595. 		fxch st(2)

    596. 

  596. 		fld st(0)

    597. 

  597. 		fmul ds:dword ptr[8+ecx]

    598. 

  598. 		fxch st(5)

    599. 

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

    600. 

  600. 		fmul ds:dword ptr[8+ebx]

    601. 

  601. 		fxch st(1)

    602. 

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

    603. 

  603. 		fxch st(3)

    604. 

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

    605. 

  605. LSetSides:

    606. 

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

    607. 

  607. 		fcomp ds:dword ptr[12+edx]

    608. 

  608. 		xor ecx,ecx

    609. 

  609. 		fnstsw ax

    610. 

  610. 		fcomp ds:dword ptr[12+edx]

    611. 

  611. 		and ah,1

    612. 

  612. 		xor ah,1

    613. 

  613. 		add cl,ah

    614. 

  614. 		fnstsw ax

    615. 

  615. 		and ah,1

    616. 

  616. 		add ah,ah

    617. 

  617. 		add cl,ah

    618. 

  618. 		pop ebx

    619. 

  619. 		mov eax,ecx

    620. 

  620. 		ret

    621. 

  621. Lerror:

    622. 

  622. 		int 3

    623. 

  623. 	}

    624. 

  624. }

    625. 

  625. #pragma warning( default: 4035 )

    626. 

  626. #endif

    627. 

  627. 

    628. 

  628. /*

    629. 

  629. =================

    630. 

  630. PlaneTypeForNormal

    631. 

  631. =================

    632. 

  632. */

    633. 

  633. int	PlaneTypeForNormal (const vec3_t normal)

    634. 

  634. {

    635. 

  635. 	vec_t	ax, ay, az;

    636. 

  636. 	

    637. 

  637. 	// NOTE: should these have an epsilon around 1.0?		

    638. 

  638. 	if (normal[0] >= 1.0f)

    639. 

  639. 		return PLANE_X;

    640. 

  640. 	if (normal[1] >= 1.0f)

    641. 

  641. 		return PLANE_Y;

    642. 

  642. 	if (normal[2] >= 1.0f)

    643. 

  643. 		return PLANE_Z;

    644. 

  644. 		

    645. 

  645. 	ax = (float)fabs( normal[0] );

    646. 

  646. 	ay = (float)fabs( normal[1] );

    647. 

  647. 	az = (float)fabs( normal[2] );

    648. 

  648. 

    649. 

  649. 	if (ax >= ay && ax >= az)

    650. 

  650. 		return PLANE_ANYX;

    651. 

  651. 	if (ay >= ax && ay >= az)

    652. 

  652. 		return PLANE_ANYY;

    653. 

  653. 	return PLANE_ANYZ;

    654. 

  654. }

    655. 

  655. 

    656. 

  656. void AddPointToBounds (const vec3_t v, vec3_t mins, vec3_t maxs)

    657. 

  657. {

    658. 

  658. 	if (v[0] < mins[0])

    659. 

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

    660. 

  660. 	if (v[0] > maxs[0])

    661. 

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

    662. 

  662. 

    663. 

  663. 	if (v[1] < mins[1])

    664. 

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

    665. 

  665. 	if (v[1] > maxs[1])

    666. 

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

    667. 

  667. 

    668. 

  668. 	if (v[2] < mins[2])

    669. 

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

    670. 

  670. 	if (v[2] > maxs[2])

    671. 

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

    672. 

  672. }

    673. 

  673. 

    674. 

  674. float RadiusFromBounds (const vec3_t mins, const vec3_t maxs)

    675. 

  675. {

    676. 

  676. 	vec3_t	corner;

    677. 

  677. 	float	val1, val2;

    678. 

  678. 

    679. 

  679. 	val1 = (float)fabs(mins[0]);

    680. 

  680. 	val2 = (float)fabs(maxs[0]);

    681. 

  681. 	corner[0] = (val1 > val2) ? val1 : val2;

    682. 

  682. 	val1 = (float)fabs(mins[1]);

    683. 

  683. 	val2 = (float)fabs(maxs[1]);

    684. 

  684. 	corner[1] = (val1 > val2) ? val1 : val2;

    685. 

  685. 	val1 = (float)fabs(mins[2]);

    686. 

  686. 	val2 = (float)fabs(maxs[2]);

    687. 

  687. 	corner[2] = (val1 > val2) ? val1 : val2;

    688. 

  688. 

    689. 

  689. 	return (float)VectorLength(corner);

    690. 

  690. }

    691. 

  691. 

    692. 

  692. vec_t VectorNormalize (vec3_t v)

    693. 

  693. {

    694. 

  694. 	float	length, ilength;

    695. 

  695. 

    696. 

  696. 	length = (float)sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); // FIXME

    697. 

  697. 

    698. 

  698. 	if (length) {

    699. 

  699. 		ilength = 1.0f/length;

    700. 

  700. 		v[0] *= ilength;

    701. 

  701. 		v[1] *= ilength;

    702. 

  702. 		v[2] *= ilength;

    703. 

  703. 	}

    704. 

  704. 

    705. 

  705. 	return length;

    706. 

  706. }

    707. 

  707. 

    708. 

  708. vec_t VectorNormalize2 (const vec3_t v, vec3_t out)

    709. 

  709. {

    710. 

  710. 	float	length, ilength;

    711. 

  711. 

    712. 

  712. 	length = (float)sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); // FIXME

    713. 

  713. 

    714. 

  714. 	if (length) {

    715. 

  715. 		ilength = 1.0f/length;

    716. 

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

    717. 

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

    718. 

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

    719. 

  719. 	} else {

    720. 

  720. 		VectorClear(out);

    721. 

  721. 	}

    722. 

  722. 

    723. 

  723. 	return length;

    724. 

  724. }

    725. 

  725. 

    726. 

  726. void VectorNormalizeFast (vec3_t v)

    727. 

  727. {

    728. 

  728. 	float ilength = Q_RSqrt( DotProduct(v,v) );

    729. 

  729. 

    730. 

  730. 	v[0] *= ilength;

    731. 

  731. 	v[1] *= ilength;

    732. 

  732. 	v[2] *= ilength;

    733. 

  733. }

    734. 

  734. 

    735. 

  735. int Q_log2(int val)

    736. 

  736. {

    737. 

  737. 	int answer=0;

    738. 

  738. 	while (val>>=1)

    739. 

  739. 		answer++;

    740. 

  740. 	return answer;

    741. 

  741. }

    742. 

  742. 

    743. 

  743. //====================================================================================

    744. 

  744. /*

    745. 

  745. ============

    746. 

  746. COM_FixPath

    747. 

  747. 

    748. 

  748. Change '\\' to '/', removes ./ and leading/ending '/'

    749. 

  749. "something/a/../b" -> "something/b"

    750. 

  750. ============

    751. 

  751. */

    752. 

  752. void COM_FixPath (char *path)

    753. 

  753. {

    754. 

  754. 	int	i, j, len = 0, lastLash = -1;

    755. 

  755. 

    756. 

  756. 	for (i = 0; path[i]; i++) {

    757. 

  757. 		switch (path[i]) {

    758. 

  758. 		case '\\':

    759. 

  759. 		case '/':

    760. 

  760. 			if(!len)

    761. 

  761. 				break;

    762. 

  762. 

    763. 

  763. 			if (path[len-1] == '/') //remove multiple /

    764. 

  764. 				break;

    765. 

  765. 

    766. 

  766. 			if(path[len-1] == '.')

    767. 

  767. 			{

    768. 

  768. 				if(len == 1 || (len >= 2 && path[len-2] != '.'))

    769. 

  769. 				{	//remove "./"

    770. 

  770. 					len--;

    771. 

  771. 					break;

    772. 

  772. 				}

    773. 

  773. 			}

    774. 

  774. 

    775. 

  775. 			lastLash = len;

    776. 

  776. 			path[len++] = '/';

    777. 

  777. 			break;

    778. 

  778. 		case '.':

    779. 

  779. 			if(len >= 2 && path[len-1] == '.')

    780. 

  780. 			{

    781. 

  781. 				if(lastLash > 0 && path[lastLash-1] != '.')

    782. 

  782. 				{	//theres lastlash and its not "../"

    783. 

  783. 					for (j = lastLash-1; j >= 0; j--)

    784. 

  784. 					{

    785. 

  785. 						if(path[j] == '/')

    786. 

  786. 							break;

    787. 

  787. 					}

    788. 

  788. 					lastLash = j;

    789. 

  789. 					len = lastLash+1;			

    790. 

  790. 					break;

    791. 

  791. 				}

    792. 

  792. 				if(path[len-2] == '.')

    793. 

  793. 					break;

    794. 

  794. 			}

    795. 

  795. 			//fallthrough

    796. 

  796. 		default:

    797. 

  797. 			path[len++] = path[i];

    798. 

  798. 			break;

    799. 

  799. 		}

    800. 

  800. 	}

    801. 

  801. 	path[len] = '\0';

    802. 

  802. 

    803. 

  803. 	if (len && path[len-1] == '/')

    804. 

  804. 		path[len-1] = '\0';

    805. 

  805. }

    806. 

  806. 

    807. 

  807. /*

    808. 

  808. ============

    809. 

  809. COM_SkipPath

    810. 

  810. ============

    811. 

  811. */

    812. 

  812. char *COM_SkipPath (const char *pathname)

    813. 

  813. {

    814. 

  814. 	const char	*last;

    815. 

  815. 	

    816. 

  816. 	last = pathname;

    817. 

  817. 	while (*pathname)

    818. 

  818. 	{

    819. 

  819. 		if (*pathname == '/' || *pathname=='\\')

    820. 

  820. 			last = pathname+1;

    821. 

  821. 

    822. 

  822. 		pathname++;

    823. 

  823. 	}

    824. 

  824. 	return (char *)last;

    825. 

  825. }

    826. 

  826. 

    827. 

  827. /*

    828. 

  828. ============

    829. 

  829. COM_StripExtension

    830. 

  830. ============

    831. 

  831. */

    832. 

  832. void COM_StripExtension (const char *in, char *out)

    833. 

  833. {

    834. 

  834. 	char *dot;

    835. 

  835. 

    836. 

  836. 	if (!(dot = strrchr(in, '.'))) {

    837. 

  837. 		strcpy(out, in);

    838. 

  838. 		return;

    839. 

  839. 	}

    840. 

  840. 	while (*in && in != dot)

    841. 

  841. 		*out++ = *in++;

    842. 

  842. 	*out = 0;

    843. 

  843. }

    844. 

  844. 

    845. 

  845. /*

    846. 

  846. ============

    847. 

  847. COM_FileExtension

    848. 

  848. ============

    849. 

  849. */

    850. 

  850. char *COM_FileExtension( const char *in )

    851. 

  851. {

    852. 

  852. 	const char *s, *last;

    853. 

  853. 

    854. 

  854. 	last = s = in + strlen( in );

    855. 

  855. 	while( s != in ) {

    856. 

  856. 		if( *s == '/' ) {

    857. 

  857. 			break;

    858. 

  858. 		}

    859. 

  859. 		if( *s == '.' ) {

    860. 

  860. 			return (char *)s;

    861. 

  861. 		}

    862. 

  862. 		s--;

    863. 

  863. 	}

    864. 

  864. 

    865. 

  865. 	return (char *)last;

    866. 

  866. }

    867. 

  867. 

    868. 

  868. /*

    869. 

  869. ============

    870. 

  870. COM_FilePath

    871. 

  871. 

    872. 

  872. Returns the path up to, but not including the last /

    873. 

  873. ============

    874. 

  874. */

    875. 

  875. void COM_FilePath (const char *in, char *out)

    876. 

  876. {

    877. 

  877. 	const char *s;

    878. 

  878. 	

    879. 

  879. 	s = in + strlen(in);

    880. 

  880. 	while (s != in && *s != '/' && *s != '\\')

    881. 

  881. 		s--;

    882. 

  882. 

    883. 

  883. 	strncpy (out,in, s-in);

    884. 

  884. 	out[s-in] = 0;

    885. 

  885. }

    886. 

  886. 

    887. 

  887. 

    888. 

  888. /*

    889. 

  889. ==================

    890. 

  890. COM_DefaultExtension

    891. 

  891. ==================

    892. 

  892. */

    893. 

  893. void COM_DefaultExtension (char *path, size_t size, const char *extension)

    894. 

  894. {

    895. 

  895. 	char    *src;

    896. 

  896. //

    897. 

  897. // if path doesn't have a .EXT, append extension

    898. 

  898. // (extension should include the .)

    899. 

  899. //

    900. 

  900. 	src = path + strlen(path);

    901. 

  901. 

    902. 

  902. 	while (*src != '/' && *src != '\\' && src != path)

    903. 

  903. 	{

    904. 

  904. 		if (*src == '.')

    905. 

  905. 			return;                 // it has an extension

    906. 

  906. 		src--;

    907. 

  907. 	}

    908. 

  908. 

    909. 

  909. 	Q_strncatz (path, extension, size);

    910. 

  910. }

    911. 

  911. 

    912. 

  912. void COM_MakePrintable (char *s)

    913. 

  913. {

    914. 

  914. 	char *string = s;

    915. 

  915. 	int	c;

    916. 

  916. 

    917. 

  917. 	while((c = *string++) != 0)

    918. 

  918. 	{

    919. 

  919. 		switch (c) {

    920. 

  920. 		case 'å':

    921. 

  921. 		case 'ä': *s++ = 'a'; break;

    922. 

  922. 		case 'Å':

    923. 

  923. 		case 'Ä': *s++ = 'A'; break;

    924. 

  924. 		case 'ö': *s++ = 'o'; break;

    925. 

  925. 		case 'Ö': *s++ = 'O'; break;

    926. 

  926. 		case '`':

    927. 

  927. 		case '´': *s++ = '\''; break;

    928. 

  928. 		default:	

    929. 

  929. 			if ( c >= 0x20 && c <= 0x7E )

    930. 

  930. 				*s++ = c;

    931. 

  931. 			break;

    932. 

  932. 		}

    933. 

  933. 	}

    934. 

  934. 	*s = '\0';

    935. 

  935. }

    936. 

  936. 

    937. 

  937. /*

    938. 

  938. ============================================================================

    939. 

  939. 

    940. 

  940. 					BYTE ORDER FUNCTIONS

    941. 

  941. 

    942. 

  942. ============================================================================

    943. 

  943. */

    944. 

  944. int16 ShortSwap (int16 l)

    945. 

  945. {

    946. 

  946. 	byte    b1, b2;

    947. 

  947. 

    948. 

  948. 	b1 = l&255;

    949. 

  949. 	b2 = (l>>8)&255;

    950. 

  950. 

    951. 

  951. 	return (b1<<8) + b2;

    952. 

  952. }

    953. 

  953. 

    954. 

  954. int32 LongSwap (int32 l)

    955. 

  955. {

    956. 

  956. 	byte    b1,b2,b3,b4;

    957. 

  957. 

    958. 

  958. 	b1 = l&255;

    959. 

  959. 	b2 = (l>>8)&255;

    960. 

  960. 	b3 = (l>>16)&255;

    961. 

  961. 	b4 = (l>>24)&255;

    962. 

  962. 

    963. 

  963. 	return ((int32)b1<<24) + ((int32)b2<<16) + ((int32)b3<<8) + b4;

    964. 

  964. }

    965. 

  965. 

    966. 

  966. float FloatSwap (float f)

    967. 

  967. {

    968. 

  968. 	union

    969. 

  969. 	{

    970. 

  970. 		float	f;

    971. 

  971. 		byte	b[4];

    972. 

  972. 	} dat1, dat2;

    973. 

  973. 	

    974. 

  974. 	

    975. 

  975. 	dat1.f = f;

    976. 

  976. 	dat2.b[0] = dat1.b[3];

    977. 

  977. 	dat2.b[1] = dat1.b[2];

    978. 

  978. 	dat2.b[2] = dat1.b[1];

    979. 

  979. 	dat2.b[3] = dat1.b[0];

    980. 

  980. 	return dat2.f;

    981. 

  981. }

    982. 

  982. 

    983. 

  983. #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)

    984. 

  984. int16   (*BigShort) (int16 l);

    985. 

  985. int16   (*LittleShort) (int16 l);

    986. 

  986. int32   (*BigLong) (int l);

    987. 

  987. int32   (*LittleLong) (int l);

    988. 

  988. float   (*BigFloat) (const float l);

    989. 

  989. float   (*LittleFloat) (const float l);

    990. 

  990. qboolean bigendien;

    991. 

  991. 

    992. 

  992. int16 ShortNoSwap (short l)

    993. 

  993. {

    994. 

  994. 	return l;

    995. 

  995. }

    996. 

  996. 

    997. 

  997. int32	LongNoSwap (int l)

    998. 

  998. {

    999. 

  999. 	return l;

    1000. 

  1000. }

    1001. 

  1001. 

    1002. 

  1002. float FloatNoSwap (const float *f)

    1003. 

  1003. {

    1004. 

  1004. 	return f;

    1005. 

  1005. }

    1006. 

  1006. 

    1007. 

  1007. /*

    1008. 

  1008. ================

    1009. 

  1009. Swap_Init

    1010. 

  1010. ================

    1011. 

  1011. */

    1012. 

  1012. void Swap_Init (void)

    1013. 

  1013. {

    1014. 

  1014. 	byte	swaptest[2] = {1,0};

    1015. 

  1015. 

    1016. 

  1016. // set the byte swapping variables in a portable manner	

    1017. 

  1017. 	if ( *(int16 *)swaptest == 1)

    1018. 

  1018. 	{

    1019. 

  1019. 		bigendien = false;

    1020. 

  1020. 		_BigShort = ShortSwap;

    1021. 

  1021. 		_LittleShort = ShortNoSwap;

    1022. 

  1022. 		_BigLong = LongSwap;

    1023. 

  1023. 		_LittleLong = LongNoSwap;

    1024. 

  1024. 		_BigFloat = FloatSwap;

    1025. 

  1025. 		_LittleFloat = FloatNoSwap;

    1026. 

  1026. 	}

    1027. 

  1027. 	else

    1028. 

  1028. 	{

    1029. 

  1029. 		bigendien = true;

    1030. 

  1030. 		_BigShort = ShortNoSwap;

    1031. 

  1031. 		_LittleShort = ShortSwap;

    1032. 

  1032. 		_BigLong = LongNoSwap;

    1033. 

  1033. 		_LittleLong = LongSwap;

    1034. 

  1034. 		_BigFloat = FloatNoSwap;

    1035. 

  1035. 		_LittleFloat = FloatSwap;

    1036. 

  1036. 	}

    1037. 

  1037. }

    1038. 

  1038. #endif

    1039. 

  1039. 

    1040. 

  1040. /*

    1041. 

  1041. ==============

    1042. 

  1042. COM_Parse

    1043. 

  1043. 

    1044. 

  1044. Parse a token out of a string

    1045. 

  1045. ==============

    1046. 

  1046. */

    1047. 

  1047. const char *COM_Parse (char **data_p)

    1048. 

  1048. {

    1049. 

  1049. 	int		c, len = 0;

    1050. 

  1050. 	char	*data;

    1051. 

  1051. 	static char	com_token[MAX_TOKEN_CHARS];

    1052. 

  1052. 

    1053. 

  1053. 	data = *data_p;

    1054. 

  1054. 	com_token[0] = 0;

    1055. 

  1055. 	

    1056. 

  1056. 	if (!data)

    1057. 

  1057. 	{

    1058. 

  1058. 		*data_p = NULL;

    1059. 

  1059. 		return com_token;

    1060. 

  1060. 	}

    1061. 

  1061. 		

    1062. 

  1062. // skip whitespace

    1063. 

  1063. 	do

    1064. 

  1064. 	{

    1065. 

  1065. 		while ((c = *data) <= ' ')

    1066. 

  1066. 		{

    1067. 

  1067. 			if (c == 0)

    1068. 

  1068. 			{

    1069. 

  1069. 				*data_p = NULL;

    1070. 

  1070. 				return com_token;

    1071. 

  1071. 			}

    1072. 

  1072. 			data++;

    1073. 

  1073. 		}

    1074. 

  1074. 		

    1075. 

  1075. 		// skip // comments

    1076. 

  1076. 		if (c == '/' && data[1] == '/')

    1077. 

  1077. 		{

    1078. 

  1078. 			data += 2;

    1079. 

  1079. 

    1080. 

  1080. 			while (*data && *data != '\n')

    1081. 

  1081. 				data++;

    1082. 

  1082. 		}

    1083. 

  1083. 		else

    1084. 

  1084. 			break;

    1085. 

  1085. 	} while(1);

    1086. 

  1086. 

    1087. 

  1087. 

    1088. 

  1088. 	// handle quoted strings specially

    1089. 

  1089. 	if (c == '\"')

    1090. 

  1090. 	{

    1091. 

  1091. 		data++;

    1092. 

  1092. 		while (1)

    1093. 

  1093. 		{

    1094. 

  1094. 			c = *data++;

    1095. 

  1095. 			if (c == '\"' || !c)

    1096. 

  1096. 				break;

    1097. 

  1097. 

    1098. 

  1098. 			if (len < MAX_TOKEN_CHARS)

    1099. 

  1099. 				com_token[len++] = c;

    1100. 

  1100. 		}

    1101. 

  1101. 	}

    1102. 

  1102. 	else

    1103. 

  1103. 	{

    1104. 

  1104. 		// parse a regular word

    1105. 

  1105. 		do

    1106. 

  1106. 		{

    1107. 

  1107. 			if (len < MAX_TOKEN_CHARS)

    1108. 

  1108. 				com_token[len++] = c;

    1109. 

  1109. 

    1110. 

  1110. 			data++;

    1111. 

  1111. 			c = *data;

    1112. 

  1112. 		} while (c>32);

    1113. 

  1113. 	}

    1114. 

  1114. 

    1115. 

  1115. 	if (len == MAX_TOKEN_CHARS)

    1116. 

  1116. 		len = 0;

    1117. 

  1117. 

    1118. 

  1118. 	com_token[len] = 0;

    1119. 

  1119. 

    1120. 

  1120. 	*data_p = data;

    1121. 

  1121. 	return com_token;

    1122. 

  1122. }

    1123. 

  1123. 

    1124. 

  1124. 

    1125. 

  1125. /*

    1126. 

  1126. ===============

    1127. 

  1127. Com_PageInMemory

    1128. 

  1128. 

    1129. 

  1129. ===============

    1130. 

  1130. */

    1131. 

  1131. static int	paged_total = 0;

    1132. 

  1132. 

    1133. 

  1133. void Com_PageInMemory (const byte *buffer, int size)

    1134. 

  1134. {

    1135. 

  1135. 	int		i;

    1136. 

  1136. 

    1137. 

  1137. 	for (i=size-1 ; i>0 ; i-=4096)

    1138. 

  1138. 		paged_total += buffer[i];

    1139. 

  1139. }

    1140. 

  1140. 

    1141. 

  1141. /*

    1142. 

  1142.  =================

    1143. 

  1143.  Com_WildCmp

    1144. 

  1144. 

    1145. 

  1145.  Wildcard compare.

    1146. 

  1146.  Returns non-zero if matches, zero otherwise.

    1147. 

  1147.  =================

    1148. 

  1148. */

    1149. 

  1149. int Com_WildCmp (const char *filter, const char *text)

    1150. 

  1150. {

    1151. 

  1151. 	int fLen, len, i, j;

    1152. 

  1152. 

    1153. 

  1153. 	while(*filter) {

    1154. 

  1154. 		if (*filter == '*') {

    1155. 

  1155. 			filter++;

    1156. 

  1156. 			while(*filter == '*' || *filter == '?') {

    1157. 

  1157. 				if(*filter++ == '?' && *text++ == '\0')

    1158. 

  1158. 					return false;

    1159. 

  1159. 			}

    1160. 

  1160. 			if(!*filter)

    1161. 

  1161. 				return true;

    1162. 

  1162. 		

    1163. 

  1163. 			for (fLen = 0; filter[fLen]; fLen++) {

    1164. 

  1164. 				if (filter[fLen] == '*' || filter[fLen] == '?')

    1165. 

  1165. 					break;

    1166. 

  1166. 			}

    1167. 

  1167. 

    1168. 

  1168. 			len = strlen(text) - fLen;

    1169. 

  1169. 			if(len < 0)

    1170. 

  1170. 				return false;

    1171. 

  1171. 

    1172. 

  1172. 			if(!filter[fLen]) {

    1173. 

  1173. 				for (text += len, j = 0; j < fLen; j++) {

    1174. 

  1174. 					if (toupper(text[j]) != toupper(filter[j]))

    1175. 

  1175. 						return false;

    1176. 

  1176. 				}

    1177. 

  1177. 				return true;

    1178. 

  1178. 			}

    1179. 

  1179. 			for (i = 0; i <= len; i++, text++) {

    1180. 

  1180. 				for (j = 0; j < fLen; j++) {

    1181. 

  1181. 					if (toupper(text[j]) != toupper(filter[j]))

    1182. 

  1182. 						break;

    1183. 

  1183. 				}

    1184. 

  1184. 				if (j == fLen && Com_WildCmp(filter+fLen, text+fLen))

    1185. 

  1185. 					return true;

    1186. 

  1186. 			}

    1187. 

  1187. 			return false;

    1188. 

  1188. 		}

    1189. 

  1189. 		else if (*filter == '?') {

    1190. 

  1190. 			if(*text++ == '\0')

    1191. 

  1191. 				return false;

    1192. 

  1192. 			filter++;

    1193. 

  1193. 		}

    1194. 

  1194. 		else {

    1195. 

  1195. 			if (toupper(*filter) != toupper(*text))

    1196. 

  1196. 				return false;

    1197. 

  1197. 

    1198. 

  1198. 			filter++;

    1199. 

  1199. 			text++;

    1200. 

  1200. 		}

    1201. 

  1201. 	}

    1202. 

  1202. 	return !*text;

    1203. 

  1203. }

    1204. 

  1204. 

    1205. 

  1205. /*

    1206. 

  1206. ==========

    1207. 

  1207. Com_HashKey

    1208. 

  1208. 

    1209. 

  1209. Returns hash key for a string

    1210. 

  1210. ==========

    1211. 

  1211. */

    1212. 

  1212. 

    1213. 

  1213. unsigned int Com_HashValue (const char *name)

    1214. 

  1214. {

    1215. 

  1215. 	unsigned int hash = 0;

    1216. 

  1216. 

    1217. 

  1217. 	while(*name)

    1218. 

  1218. 		hash = hash * 33 + Q_tolower(*name++);

    1219. 

  1219. 

    1220. 

  1220. 	return hash + (hash >> 5);

    1221. 

  1221. }

    1222. 

  1222. 

    1223. 

  1223. unsigned int Com_HashValuePath (const char *name)

    1224. 

  1224. {

    1225. 

  1225. 	unsigned int c, hash = 0;

    1226. 

  1226. 

    1227. 

  1227. 	while(*name) {

    1228. 

  1228. 		c = Q_tolower(*name++);

    1229. 

  1229. 		if( c == '\\' )

    1230. 

  1230. 			c = '/';

    1231. 

  1231. 		hash = hash * 33 + c;

    1232. 

  1232. 	}

    1233. 

  1233. 	return hash + (hash >> 5);

    1234. 

  1234. }

    1235. 

  1235. 

    1236. 

  1236. /*

    1237. 

  1237. ============================================================================

    1238. 

  1238. 

    1239. 

  1239. 					LIBRARY REPLACEMENT FUNCTIONS

    1240. 

  1240. 

    1241. 

  1241. ============================================================================

    1242. 

  1242. */

    1243. 

  1243. 

    1244. 

  1244. #ifndef Q_strnicmp

    1245. 

  1245. int Q_strnicmp (const char *s1, const char *s2, size_t size)

    1246. 

  1246. {

    1247. 

  1247. 	int		c1, c2;

    1248. 

  1248. 	

    1249. 

  1249. 	do

    1250. 

  1250. 	{

    1251. 

  1251. 		c1 = *s1++;

    1252. 

  1252. 		c2 = *s2++;

    1253. 

  1253. 

    1254. 

  1254. 		if (!size--)

    1255. 

  1255. 			return 0;		// strings are equal until end point

    1256. 

  1256. 		

    1257. 

  1257. 		if (c1 != c2)

    1258. 

  1258. 		{

    1259. 

  1259. 			if (c1 >= 'a' && c1 <= 'z')

    1260. 

  1260. 				c1 -= ('a' - 'A');

    1261. 

  1261. 			if (c2 >= 'a' && c2 <= 'z')

    1262. 

  1262. 				c2 -= ('a' - 'A');

    1263. 

  1263. 			if (c1 != c2)

    1264. 

  1264. 				return c1 < c2 ? -1 : 1;	// strings not equal

    1265. 

  1265. 		}

    1266. 

  1266. 	} while (c1);

    1267. 

  1267. 	

    1268. 

  1268. 	return 0;		// strings are equal

    1269. 

  1269. }

    1270. 

  1270. #endif

    1271. 

  1271. 

    1272. 

  1272. /*

    1273. 

  1273. ============

    1274. 

  1274. Q_stristr

    1275. 

  1275. ============

    1276. 

  1276. */

    1277. 

  1277. char *Q_stristr(const char *str1, const char *str2)

    1278. 

  1278. {

    1279. 

  1279. 	int len, i, j;

    1280. 

  1280. 

    1281. 

  1281. 	len = strlen(str1) - strlen(str2);

    1282. 

  1282. 	for (i = 0; i <= len; i++, str1++) {

    1283. 

  1283. 		for (j = 0; str2[j]; j++) {

    1284. 

  1284. 			if (toupper(str1[j]) != toupper(str2[j]))

    1285. 

  1285. 				break;

    1286. 

  1286. 		}

    1287. 

  1287. 		if (!str2[j])

    1288. 

  1288. 			return (char *)str1;

    1289. 

  1289. 	}

    1290. 

  1290. 	return NULL;

    1291. 

  1291. }

    1292. 

  1292. 

    1293. 

  1293. #ifndef NDEBUG

    1294. 

  1294. void Com_Error (int code, const char *fmt, ...);

    1295. 

  1295. #endif

    1296. 

  1296. 

    1297. 

  1297. void Q_strncpyz( char *dest, const char *src, size_t size )

    1298. 

  1298. {

    1299. 

  1299. #ifndef NDEBUG

    1300. 

  1300. 	if ( !dest )

    1301. 

  1301. 		Com_Error(ERR_FATAL, "Q_strncpyz: NULL dest" );

    1302. 

  1302. 

    1303. 

  1303. 	if ( !src )

    1304. 

  1304. 		Com_Error(ERR_FATAL, "Q_strncpyz: NULL src" );

    1305. 

  1305. 

    1306. 

  1306. 	if ( size < 1 )

    1307. 

  1307. 		Com_Error(ERR_FATAL, "Q_strncpyz: size < 1" ); 

    1308. 

  1308. #endif

    1309. 

  1309. 

    1310. 

  1310. 	if( size ) {

    1311. 

  1311. 		while( --size && (*dest++ = *src++) );

    1312. 

  1312. 		*dest = '\0';

    1313. 

  1313. 	}

    1314. 

  1314. }

    1315. 

  1315. /*

    1316. 

  1316. ==============

    1317. 

  1317. Q_strncatz

    1318. 

  1318. ==============

    1319. 

  1319. */

    1320. 

  1320. void Q_strncatz( char *dest, const char *src, size_t size )

    1321. 

  1321. {

    1322. 

  1322. #ifndef NDEBUG

    1323. 

  1323. 	if ( !dest )

    1324. 

  1324. 		Com_Error(ERR_FATAL, "Q_strncatz: NULL dest" );

    1325. 

  1325. 

    1326. 

  1326. 	if ( !src )

    1327. 

  1327. 		Com_Error(ERR_FATAL, "Q_strncatz: NULL src" );

    1328. 

  1328. 

    1329. 

  1329. 	if ( size < 1 )

    1330. 

  1330. 		Com_Error(ERR_FATAL, "Q_strncatz: size < 1" ); 

    1331. 

  1331. #endif

    1332. 

  1332. 	if(size) {

    1333. 

  1333. 		while( --size && *dest++ );

    1334. 

  1334. 		if( size ) {

    1335. 

  1335. 			dest--;

    1336. 

  1336. 			while( --size && (*dest++ = *src++) );

    1337. 

  1337. 		}

    1338. 

  1338. 		*dest = '\0';

    1339. 

  1339. 	}

    1340. 

  1340. }

    1341. 

  1341. 

    1342. 

  1342. void Com_sprintf (char *dest, size_t size, const char *fmt, ...)

    1343. 

  1343. {

    1344. 

  1344. 	va_list		argptr;

    1345. 

  1345. 

    1346. 

  1346. #ifndef NDEBUG

    1347. 

  1347. 	if ( !dest )

    1348. 

  1348. 		Com_Error(ERR_FATAL, "Q_strncatz: NULL dest" );

    1349. 

  1349. 

    1350. 

  1350. 	if ( size < 1 )

    1351. 

  1351. 		Com_Error(ERR_FATAL, "Q_strncatz: size < 1" ); 

    1352. 

  1352. #endif

    1353. 

  1353. 

    1354. 

  1354. 	if(size) {

    1355. 

  1355. 		va_start( argptr, fmt );

    1356. 

  1356. 		vsnprintf( dest, size, fmt, argptr );

    1357. 

  1357. 		va_end( argptr );

    1358. 

  1358. 	}

    1359. 

  1359. }

    1360. 

  1360. 

    1361. 

  1361. /*

    1362. 

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

    1363. 

  1363. va

    1364. 

  1364. does a varargs printf into a temp buffer, so I don't need to have

    1365. 

  1365. varargs versions of all text functions.

    1366. 

  1366. ============

    1367. 

  1367. */

    1368. 

  1368. char	*va(const char *format, ...)

    1369. 

  1369. {

    1370. 

  1370. 	va_list		argptr;

    1371. 

  1371. 	static int  index = 0;

    1372. 

  1372. 	static char	string[2][2048];

    1373. 

  1373. 

    1374. 

  1374. 	index  ^= 1;

    1375. 

  1375. 	va_start (argptr, format);

    1376. 

  1376. 	vsnprintf (string[index], sizeof(string[index]), format, argptr);

    1377. 

  1377. 	va_end (argptr);

    1378. 

  1378. 

    1379. 

  1379. 	return string[index];

    1380. 

  1380. }

    1381. 

  1381. 

    1382. 

  1382. 

    1383. 

  1383. int Q_tolower( int c ) {

    1384. 

  1384. 	if( Q_isupper( c ) ) {

    1385. 

  1385. 		c += ( 'a' - 'A' );

    1386. 

  1386. 	}

    1387. 

  1387. 

    1388. 

  1388. 	return c;

    1389. 

  1389. }

    1390. 

  1390. 

    1391. 

  1391. int Q_toupper( int c ) {

    1392. 

  1392. 	if( Q_islower( c ) ) {

    1393. 

  1393. 		c -= ( 'a' - 'A' );

    1394. 

  1394. 	}

    1395. 

  1395. 

    1396. 

  1396. 	return c;

    1397. 

  1397. }

    1398. 

  1398. 

    1399. 

  1399. /*

    1400. 

  1400. ==============

    1401. 

  1401. Q_strlwr

    1402. 

  1402. ==============

    1403. 

  1403. */

    1404. 

  1404. char *Q_strlwr( char *s )

    1405. 

  1405. {

    1406. 

  1406. 	char *p;

    1407. 

  1407. 

    1408. 

  1408. 	for( p = s; *s; s++ ) {

    1409. 

  1409. 		if(Q_isupper(*s))

    1410. 

  1410. 			*s += 'a' - 'A';

    1411. 

  1411. 	}

    1412. 

  1412. 

    1413. 

  1413. 	return p;

    1414. 

  1414. }

    1415. 

  1415. 

    1416. 

  1416. char *Q_strupr( char *s )

    1417. 

  1417. {

    1418. 

  1418. 	char *p;

    1419. 

  1419. 

    1420. 

  1420. 	for( p = s; *s; s++ ) {

    1421. 

  1421. 		if(Q_islower(*s))

    1422. 

  1422. 			*s -= 'a' - 'A';

    1423. 

  1423. 	}

    1424. 

  1424. 

    1425. 

  1425. 	return p;

    1426. 

  1426. }

    1427. 

  1427. 

    1428. 

  1428. /*

    1429. 

  1429. ==============

    1430. 

  1430. Q_IsNumeric

    1431. 

  1431. ==============

    1432. 

  1432. */

    1433. 

  1433. qboolean Q_IsNumeric (const char *s)

    1434. 

  1434. {

    1435. 

  1435. 	qboolean dot;

    1436. 

  1436. 

    1437. 

  1437. 	if(!s)

    1438. 

  1438. 		return false;

    1439. 

  1439. 

    1440. 

  1440. 	if (*s == '-')
    1441. 

  1441. 		s++;

    1442. 

  1442. 

    1443. 

  1443. 	dot = false;

    1444. 

  1444. 	do

    1445. 

  1445. 	{

    1446. 

  1446. 		if(!Q_isdigit(*s)) {

    1447. 

  1447. 			if(*s == '.' && !dot)

    1448. 

  1448. 				dot = true;

    1449. 

  1449. 			else

    1450. 

  1450. 				return false;

    1451. 

  1451. 		}

    1452. 

  1452. 		s++;

    1453. 

  1453. 	} while(*s);

    1454. 

  1454. 

    1455. 

  1455. 	return true;

    1456. 

  1456. }

    1457. 

  1457. /*

    1458. 

  1458. =====================================================================

    1459. 

  1459. 

    1460. 

  1460.   INFO STRINGS

    1461. 

  1461. 

    1462. 

  1462. =====================================================================

    1463. 

  1463. */

    1464. 

  1464. 

    1465. 

  1465. /*

    1466. 

  1466. ===============

    1467. 

  1467. Info_ValueForKey

    1468. 

  1468. 

    1469. 

  1469. Searches the string for the given

    1470. 

  1470. key and returns the associated value, or an empty string.

    1471. 

  1471. ===============

    1472. 

  1472. */

    1473. 

  1473. char *Info_ValueForKey (const char *s, const char *key)

    1474. 

  1474. {

    1475. 

  1475. 	char	pkey[MAX_INFO_STRING];

    1476. 

  1476. 	static	char value[2][MAX_INFO_STRING];	// use two buffers so compares

    1477. 

  1477. 											// work without stomping on each other

    1478. 

  1478. 	static	int	valueindex = 0;

    1479. 

  1479. 	char	*o;

    1480. 

  1480. 	

    1481. 

  1481. 	if ( !s || !key )

    1482. 

  1482. 		return "";

    1483. 

  1483. 

    1484. 

  1484. 	valueindex ^= 1;

    1485. 

  1485. 	if (*s == '\\')

    1486. 

  1486. 		s++;

    1487. 

  1487. 	while (1)

    1488. 

  1488. 	{

    1489. 

  1489. 		o = pkey;

    1490. 

  1490. 		while (*s != '\\')

    1491. 

  1491. 		{

    1492. 

  1492. 			if (!*s)

    1493. 

  1493. 				return "";

    1494. 

  1494. 			*o++ = *s++;

    1495. 

  1495. 		}

    1496. 

  1496. 		*o = 0;

    1497. 

  1497. 		s++;

    1498. 

  1498. 

    1499. 

  1499. 		o = value[valueindex];

    1500. 

  1500. 

    1501. 

  1501. 		while (*s != '\\' && *s)

    1502. 

  1502. 		{

    1503. 

  1503. 			*o++ = *s++;

    1504. 

  1504. 		}

    1505. 

  1505. 		*o = 0;

    1506. 

  1506. 

    1507. 

  1507. 		if (!strcmp (key, pkey) )

    1508. 

  1508. 			return value[valueindex];

    1509. 

  1509. 

    1510. 

  1510. 		if (!*s)

    1511. 

  1511. 			break;

    1512. 

  1512. 		s++;

    1513. 

  1513. 	}

    1514. 

  1514. 

    1515. 

  1515. 	return "";

    1516. 

  1516. }

    1517. 

  1517. 

    1518. 

  1518. /*

    1519. 

  1519. ===================

    1520. 

  1520. Info_NextPair

    1521. 

  1521. 

    1522. 

  1522. Used to itterate through all the key/value pairs in an info string

    1523. 

  1523. ===================

    1524. 

  1524. */

    1525. 

  1525. void Info_NextPair( const char **head, char *key, char *value ) {

    1526. 

  1526. 	char	*o;

    1527. 

  1527. 	const char	*s;

    1528. 

  1528. 

    1529. 

  1529. 	key[0] = 0;

    1530. 

  1530. 	value[0] = 0;

    1531. 

  1531. 

    1532. 

  1532. 	s = *head;

    1533. 

  1533. 	if( !s )

    1534. 

  1534. 		return;

    1535. 

  1535. 

    1536. 

  1536. 	if ( *s == '\\' )

    1537. 

  1537. 		s++;

    1538. 

  1538. 

    1539. 

  1539. 	o = key;

    1540. 

  1540. 	while( *s && *s != '\\' )

    1541. 

  1541. 		*o++ = *s++;

    1542. 

  1542. 

    1543. 

  1543. 	*o = 0;

    1544. 

  1544. 

    1545. 

  1545. 	if( !*s ) {

    1546. 

  1546. 		*head = s;

    1547. 

  1547. 		return;

    1548. 

  1548. 	}

    1549. 

  1549. 

    1550. 

  1550. 	s++;

    1551. 

  1551. 	o = value;

    1552. 

  1552. 	while( *s && *s != '\\' )

    1553. 

  1553. 		*o++ = *s++;

    1554. 

  1554. 

    1555. 

  1555. 	*o = 0;

    1556. 

  1556. 

    1557. 

  1557. 	*head = s;

    1558. 

  1558. }

    1559. 

  1559. 

    1560. 

  1560. /*

    1561. 

  1561. ===================

    1562. 

  1562. Info_RemoveKey

    1563. 

  1563. ===================

    1564. 

  1564. */

    1565. 

  1565. void Info_RemoveKey (char *s, const char *key)

    1566. 

  1566. {

    1567. 

  1567. 	char	*start;

    1568. 

  1568. 	char	pkey[MAX_INFO_KEY];

    1569. 

  1569. 	char	value[MAX_INFO_VALUE];

    1570. 

  1570. 	char	*o;

    1571. 

  1571. 

    1572. 

  1572. 	if (strchr (key, '\\'))

    1573. 

  1573. 	{

    1574. 

  1574. 		Com_Printf ("Info_RemoveKey: Tried to remove illegal key '%s'\n", key);

    1575. 

  1575. 		return;

    1576. 

  1576. 	}

    1577. 

  1577. 

    1578. 

  1578. 	while (1)

    1579. 

  1579. 	{

    1580. 

  1580. 		start = s;

    1581. 

  1581. 		if (*s == '\\')

    1582. 

  1582. 			s++;

    1583. 

  1583. 		o = pkey;

    1584. 

  1584. 		while (*s != '\\')

    1585. 

  1585. 		{

    1586. 

  1586. 			if (!*s)

    1587. 

  1587. 				return;

    1588. 

  1588. 			*o++ = *s++;

    1589. 

  1589. 		}

    1590. 

  1590. 		*o = 0;

    1591. 

  1591. 

    1592. 

  1592. 		s++;

    1593. 

  1593. 

    1594. 

  1594. 		o = value;

    1595. 

  1595. 		while (*s != '\\' && *s)

    1596. 

  1596. 		{

    1597. 

  1597. 			*o++ = *s++;

    1598. 

  1598. 		}

    1599. 

  1599. 		*o = 0;

    1600. 

  1600. 

    1601. 

  1601. 		if (!strcmp(key, pkey)) {

    1602. 

  1602. 			strcpy(start, s);	// remove this part

    1603. 

  1603. 			return;

    1604. 

  1604. 		}

    1605. 

  1605. 

    1606. 

  1606. 		if (!*s)

    1607. 

  1607. 			return;

    1608. 

  1608. 	}

    1609. 

  1609. }

    1610. 

  1610. 

    1611. 

  1611. 

    1612. 

  1612. /*

    1613. 

  1613. ==================

    1614. 

  1614. Info_Validate

    1615. 

  1615. 

    1616. 

  1616. Some characters are illegal in info strings because they

    1617. 

  1617. can mess up the server's parsing

    1618. 

  1618. ==================

    1619. 

  1619. */

    1620. 

  1620. qboolean Info_Validate (const char *s)

    1621. 

  1621. {

    1622. 

  1622. 	while( *s ) {

    1623. 

  1623. 		if( *s == '\"' || *s == ';' ) {

    1624. 

  1624. 			return false;

    1625. 

  1625. 		}

    1626. 

  1626. 		s++;

    1627. 

  1627. 	}

    1628. 

  1628. 	return true;

    1629. 

  1629. }

    1630. 

  1630. 

    1631. 

  1631. void Info_SetValueForKey (char *s, const char *key, const char *value)

    1632. 

  1632. {

    1633. 

  1633. 	char	newi[MAX_INFO_STRING], *v;

    1634. 

  1634. 	int		c;

    1635. 

  1635. 

    1636. 

  1636. 	if (!key || !value)

    1637. 

  1637. 		return;

    1638. 

  1638. 

    1639. 

  1639. 	if (strchr (key, '\\') || strchr (value, '\\') )

    1640. 

  1640. 	{

    1641. 

  1641. 		Com_Printf ("Can't use keys or values with a \\ (attempted to set key '%s')\n", key);

    1642. 

  1642. 		return;

    1643. 

  1643. 	}

    1644. 

  1644. 

    1645. 

  1645. 	if (strchr (key, ';') || strchr (value, ';') )

    1646. 

  1646. 	{

    1647. 

  1647. 		Com_Printf ("Can't use keys or values with a semicolon (attempted to set key '%s')\n", key);

    1648. 

  1648. 		return;

    1649. 

  1649. 	}

    1650. 

  1650. 

    1651. 

  1651. 	if (strchr (key, '"') || strchr (value, '"') )

    1652. 

  1652. 	{

    1653. 

  1653. 		Com_Printf ("Can't use keys or values with a \" (attempted to set key '%s')\n", key);

    1654. 

  1654. 		return;

    1655. 

  1655. 	}

    1656. 

  1656. 

    1657. 

  1657. 	if (strlen(key) > MAX_INFO_KEY-1 || strlen(value) > MAX_INFO_KEY-1)

    1658. 

  1658. 	{

    1659. 

  1659. 		Com_Printf ("Keys and values must be < 64 characters (attempted to set key '%s')\n", key);

    1660. 

  1660. 		return;

    1661. 

  1661. 	}

    1662. 

  1662. 

    1663. 

  1663. 	Info_RemoveKey (s, key);

    1664. 

  1664. 

    1665. 

  1665. 	if (!value[0])

    1666. 

  1666. 		return;

    1667. 

  1667. 

    1668. 

  1668. 	Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);

    1669. 

  1669. 

    1670. 

  1670. 	if (strlen(newi) + strlen(s) >= MAX_INFO_STRING)

    1671. 

  1671. 	{

    1672. 

  1672. 		Com_Printf ("Info string length exceeded while trying to set '%s'\n", newi);

    1673. 

  1673. 		return;

    1674. 

  1674. 	}

    1675. 

  1675. 

    1676. 

  1676. 	// only copy ascii values

    1677. 

  1677. 	s += strlen(s);

    1678. 

  1678. 	v = newi;

    1679. 

  1679. 	while (*v)

    1680. 

  1680. 	{

    1681. 

  1681. 		c = *v++;

    1682. 

  1682. 		c &= 127;		// strip high bits

    1683. 

  1683. 		if (c >= 32 && c < 127)

    1684. 

  1684. 			*s++ = c;

    1685. 

  1685. 	}

    1686. 

  1686. 	*s = 0;

    1687. 

  1687. }

    1688. 

  1688.