PageRenderTime 46ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/deps/glm-0.9.4.0/test/core/core_type_vec3.cpp

https://bitbucket.org/sturmh/dirtygraphics
C++ | 439 lines | 315 code | 89 blank | 35 comment | 278 complexity | 04b97c86e8d5deb9a79185e1072263ed MD5 | raw file
  1. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2. // OpenGL Mathematics Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
  3. ///////////////////////////////////////////////////////////////////////////////////////////////////
  4. // Created : 2008-08-31
  5. // Updated : 2011-09-19
  6. // Licence : This source is under MIT License
  7. // File : test/core/type_vec3.cpp
  8. ///////////////////////////////////////////////////////////////////////////////////////////////////
  9. #define GLM_SWIZZLE
  10. #include <glm/glm.hpp>
  11. #include <glm/gtc/half_float.hpp>
  12. #include <cstdio>
  13. #include <vector>
  14. int test_vec3_ctor()
  15. {
  16. int Error = 0;
  17. {
  18. glm::vec3 A(1);
  19. glm::vec3 B(1, 1, 1);
  20. Error += A == B ? 0 : 1;
  21. }
  22. {
  23. std::vector<glm::vec3> Tests;
  24. Tests.push_back(glm::vec3(glm::vec2(1, 2), 3));
  25. Tests.push_back(glm::vec3(1, glm::vec2(2, 3)));
  26. Tests.push_back(glm::vec3(1, 2, 3));
  27. Tests.push_back(glm::vec3(glm::vec4(1, 2, 3, 4)));
  28. for(std::size_t i = 0; i < Tests.size(); ++i)
  29. Error += Tests[i] == glm::vec3(1, 2, 3) ? 0 : 1;
  30. }
  31. return Error;
  32. }
  33. int test_vec3_operators()
  34. {
  35. int Error = 0;
  36. {
  37. glm::vec3 A(1.0f);
  38. glm::vec3 B(1.0f);
  39. bool R = A != B;
  40. bool S = A == B;
  41. Error += (S && !R) ? 0 : 1;
  42. }
  43. {
  44. glm::vec3 A(1.0f, 2.0f, 3.0f);
  45. glm::vec3 B(4.0f, 5.0f, 6.0f);
  46. glm::vec3 C = A + B;
  47. Error += C == glm::vec3(5, 7, 9) ? 0 : 1;
  48. glm::vec3 D = B - A;
  49. Error += D == glm::vec3(3, 3, 3) ? 0 : 1;
  50. glm::vec3 E = A * B;
  51. Error += E == glm::vec3(4, 10, 18) ? 0 : 1;
  52. glm::vec3 F = B / A;
  53. Error += F == glm::vec3(4, 2.5, 2) ? 0 : 1;
  54. glm::vec3 G = A + 1.0f;
  55. Error += G == glm::vec3(2, 3, 4) ? 0 : 1;
  56. glm::vec3 H = B - 1.0f;
  57. Error += H == glm::vec3(3, 4, 5) ? 0 : 1;
  58. glm::vec3 I = A * 2.0f;
  59. Error += I == glm::vec3(2, 4, 6) ? 0 : 1;
  60. glm::vec3 J = B / 2.0f;
  61. Error += J == glm::vec3(2, 2.5, 3) ? 0 : 1;
  62. glm::vec3 K = 1.0f + A;
  63. Error += K == glm::vec3(2, 3, 4) ? 0 : 1;
  64. glm::vec3 L = 1.0f - B;
  65. Error += L == glm::vec3(-3, -4, -5) ? 0 : 1;
  66. glm::vec3 M = 2.0f * A;
  67. Error += M == glm::vec3(2, 4, 6) ? 0 : 1;
  68. glm::vec3 N = 2.0f / B;
  69. Error += N == glm::vec3(0.5, 2.0 / 5.0, 2.0 / 6.0) ? 0 : 1;
  70. }
  71. {
  72. glm::vec3 A(1.0f, 2.0f, 3.0f);
  73. glm::vec3 B(4.0f, 5.0f, 6.0f);
  74. A += B;
  75. Error += A == glm::vec3(5, 7, 9) ? 0 : 1;
  76. A += 1.0f;
  77. Error += A == glm::vec3(6, 8, 10) ? 0 : 1;
  78. }
  79. {
  80. glm::vec3 A(1.0f, 2.0f, 3.0f);
  81. glm::vec3 B(4.0f, 5.0f, 6.0f);
  82. B -= A;
  83. Error += B == glm::vec3(3, 3, 3) ? 0 : 1;
  84. B -= 1.0f;
  85. Error += B == glm::vec3(2, 2, 2) ? 0 : 1;
  86. }
  87. {
  88. glm::vec3 A(1.0f, 2.0f, 3.0f);
  89. glm::vec3 B(4.0f, 5.0f, 6.0f);
  90. A *= B;
  91. Error += A == glm::vec3(4, 10, 18) ? 0 : 1;
  92. A *= 2.0f;
  93. Error += A == glm::vec3(8, 20, 36) ? 0 : 1;
  94. }
  95. {
  96. glm::vec3 A(1.0f, 2.0f, 3.0f);
  97. glm::vec3 B(4.0f, 5.0f, 6.0f);
  98. B /= A;
  99. Error += B == glm::vec3(4, 2.5, 2) ? 0 : 1;
  100. B /= 2.0f;
  101. Error += B == glm::vec3(2, 1.25, 1) ? 0 : 1;
  102. }
  103. {
  104. glm::vec3 A(1.0f, 2.0f, 3.0f);
  105. glm::vec3 B = -A;
  106. Error += B == glm::vec3(-1.0f, -2.0f, -3.0f) ? 0 : 1;
  107. }
  108. {
  109. glm::vec3 A(1.0f, 2.0f, 3.0f);
  110. glm::vec3 B = --A;
  111. Error += B == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
  112. }
  113. {
  114. glm::vec3 A(1.0f, 2.0f, 3.0f);
  115. glm::vec3 B = A--;
  116. Error += B == glm::vec3(0.0f, 1.0f, 2.0f) ? 0 : 1;
  117. }
  118. {
  119. glm::vec3 A(1.0f, 2.0f, 3.0f);
  120. glm::vec3 B = ++A;
  121. Error += B == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
  122. }
  123. {
  124. glm::vec3 A(1.0f, 2.0f, 3.0f);
  125. glm::vec3 B = A++;
  126. Error += B == glm::vec3(2.0f, 3.0f, 4.0f) ? 0 : 1;
  127. }
  128. return Error;
  129. }
  130. int test_vec3_size()
  131. {
  132. int Error = 0;
  133. Error += sizeof(glm::vec3) == sizeof(glm::mediump_vec3) ? 0 : 1;
  134. Error += 12 == sizeof(glm::mediump_vec3) ? 0 : 1;
  135. Error += sizeof(glm::dvec3) == sizeof(glm::highp_vec3) ? 0 : 1;
  136. Error += 24 == sizeof(glm::highp_vec3) ? 0 : 1;
  137. Error += glm::vec3().length() == 3 ? 0 : 1;
  138. Error += glm::dvec3().length() == 3 ? 0 : 1;
  139. return Error;
  140. }
  141. int test_vec3_swizzle3_2()
  142. {
  143. int Error = 0;
  144. glm::vec3 v(1, 2, 3);
  145. glm::vec2 u;
  146. // Can not assign a vec3 swizzle to a vec2
  147. //u = v.xyz; //Illegal
  148. //u = v.rgb; //Illegal
  149. //u = v.stp; //Illegal
  150. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  151. u = v.xx; Error += (u.x == 1.0f && u.y == 1.0f) ? 0 : 1;
  152. u = v.xy; Error += (u.x == 1.0f && u.y == 2.0f) ? 0 : 1;
  153. u = v.xz; Error += (u.x == 1.0f && u.y == 3.0f) ? 0 : 1;
  154. u = v.yx; Error += (u.x == 2.0f && u.y == 1.0f) ? 0 : 1;
  155. u = v.yy; Error += (u.x == 2.0f && u.y == 2.0f) ? 0 : 1;
  156. u = v.yz; Error += (u.x == 2.0f && u.y == 3.0f) ? 0 : 1;
  157. u = v.zx; Error += (u.x == 3.0f && u.y == 1.0f) ? 0 : 1;
  158. u = v.zy; Error += (u.x == 3.0f && u.y == 2.0f) ? 0 : 1;
  159. u = v.zz; Error += (u.x == 3.0f && u.y == 3.0f) ? 0 : 1;
  160. u = v.rr; Error += (u.r == 1.0f && u.g == 1.0f) ? 0 : 1;
  161. u = v.rg; Error += (u.r == 1.0f && u.g == 2.0f) ? 0 : 1;
  162. u = v.rb; Error += (u.r == 1.0f && u.g == 3.0f) ? 0 : 1;
  163. u = v.gr; Error += (u.r == 2.0f && u.g == 1.0f) ? 0 : 1;
  164. u = v.gg; Error += (u.r == 2.0f && u.g == 2.0f) ? 0 : 1;
  165. u = v.gb; Error += (u.r == 2.0f && u.g == 3.0f) ? 0 : 1;
  166. u = v.br; Error += (u.r == 3.0f && u.g == 1.0f) ? 0 : 1;
  167. u = v.bg; Error += (u.r == 3.0f && u.g == 2.0f) ? 0 : 1;
  168. u = v.bb; Error += (u.r == 3.0f && u.g == 3.0f) ? 0 : 1;
  169. u = v.ss; Error += (u.s == 1.0f && u.t == 1.0f) ? 0 : 1;
  170. u = v.st; Error += (u.s == 1.0f && u.t == 2.0f) ? 0 : 1;
  171. u = v.sp; Error += (u.s == 1.0f && u.t == 3.0f) ? 0 : 1;
  172. u = v.ts; Error += (u.s == 2.0f && u.t == 1.0f) ? 0 : 1;
  173. u = v.tt; Error += (u.s == 2.0f && u.t == 2.0f) ? 0 : 1;
  174. u = v.tp; Error += (u.s == 2.0f && u.t == 3.0f) ? 0 : 1;
  175. u = v.ps; Error += (u.s == 3.0f && u.t == 1.0f) ? 0 : 1;
  176. u = v.pt; Error += (u.s == 3.0f && u.t == 2.0f) ? 0 : 1;
  177. u = v.pp; Error += (u.s == 3.0f && u.t == 3.0f) ? 0 : 1;
  178. // Mixed member aliases are not valid
  179. //u = v.rx; //Illegal
  180. //u = v.sy; //Illegal
  181. u = glm::vec2(1, 2);
  182. v = glm::vec3(1, 2, 3);
  183. //v.xx = u; //Illegal
  184. v.xy = u; Error += (v.x == 1.0f && v.y == 2.0f && v.z == 3.0f) ? 0 : 1;
  185. v.xz = u; Error += (v.x == 1.0f && v.y == 2.0f && v.z == 2.0f) ? 0 : 1;
  186. v.yx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 2.0f) ? 0 : 1;
  187. //v.yy = u; //Illegal
  188. v.yz = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 2.0f) ? 0 : 1;
  189. v.zx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 1.0f) ? 0 : 1;
  190. v.zy = u; Error += (v.x == 2.0f && v.y == 2.0f && v.z == 1.0f) ? 0 : 1;
  191. //v.zz = u; //Illegal
  192. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  193. return Error;
  194. }
  195. int test_vec3_swizzle3_3()
  196. {
  197. int Error = 0;
  198. glm::vec3 v(1, 2, 3);
  199. glm::vec3 u;
  200. u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
  201. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  202. u = v.xyz; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
  203. u = v.zyx; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  204. u.zyx = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  205. u = v.rgb; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
  206. u = v.bgr; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  207. u.bgr = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  208. u = v.stp; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
  209. u = v.pts; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  210. u.pts = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
  211. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  212. return Error;
  213. }
  214. int test_vec3_swizzle_half()
  215. {
  216. int Error = 0;
  217. glm::half a1(1);
  218. glm::half b1(2);
  219. glm::half c1(3);
  220. glm::hvec3 v(a1, b1, c1);
  221. glm::hvec3 u;
  222. u = v;
  223. Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1;
  224. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  225. u = v.xyz;
  226. Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1;
  227. u = v.zyx;
  228. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  229. u.zyx = v;
  230. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  231. u = v.rgb;
  232. Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1;
  233. u = v.bgr;
  234. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  235. u.bgr = v;
  236. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  237. u = v.stp;
  238. Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1;
  239. u = v.pts;
  240. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  241. u.pts = v;
  242. Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1;
  243. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  244. return Error;
  245. }
  246. int test_vec3_swizzle_operators()
  247. {
  248. int Error = 0;
  249. glm::vec3 q, u, v;
  250. u = glm::vec3(1, 2, 3);
  251. v = glm::vec3(10, 20, 30);
  252. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  253. // Swizzle, swizzle binary operators
  254. q = u.xyz + v.xyz; Error += (q == (u + v)) ? 0 : 1;
  255. q = (u.zyx + v.zyx).zyx; Error += (q == (u + v)) ? 0 : 1;
  256. q = (u.xyz - v.xyz); Error += (q == (u - v)) ? 0 : 1;
  257. q = (u.xyz * v.xyz); Error += (q == (u * v)) ? 0 : 1;
  258. q = (u.xxx * v.xxx); Error += (q == glm::vec3(u.x * v.x)) ? 0 : 1;
  259. q = (u.xyz / v.xyz); Error += (q == (u / v)) ? 0 : 1;
  260. // vec, swizzle binary operators
  261. q = u + v.xyz; Error += (q == (u + v)) ? 0 : 1;
  262. q = (u - v.xyz); Error += (q == (u - v)) ? 0 : 1;
  263. q = (u * v.xyz); Error += (q == (u * v)) ? 0 : 1;
  264. q = (u * v.xxx); Error += (q == v.x * u) ? 0 : 1;
  265. q = (u / v.xyz); Error += (q == (u / v)) ? 0 : 1;
  266. // swizzle,vec binary operators
  267. q = u.xyz + v; Error += (q == (u + v)) ? 0 : 1;
  268. q = (u.xyz - v); Error += (q == (u - v)) ? 0 : 1;
  269. q = (u.xyz * v); Error += (q == (u * v)) ? 0 : 1;
  270. q = (u.xxx * v); Error += (q == u.x * v) ? 0 : 1;
  271. q = (u.xyz / v); Error += (q == (u / v)) ? 0 : 1;
  272. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  273. // Compile errors
  274. //q = (u.yz * v.xyz);
  275. //q = (u * v.xy);
  276. return Error;
  277. }
  278. int test_vec3_swizzle_functions()
  279. {
  280. int Error = 0;
  281. //
  282. // NOTE: template functions cannot pick up the implicit conversion from
  283. // a swizzle to the unswizzled type, therefore the operator() must be
  284. // used. E.g.:
  285. //
  286. // glm::dot(u.xy, v.xy); <--- Compile error
  287. // glm::dot(u.xy(), v.xy()); <--- Compiles correctly
  288. //
  289. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  290. float r;
  291. // vec2
  292. glm::vec2 a(1, 2);
  293. glm::vec2 b(10, 20);
  294. r = glm::dot(a, b); Error += (int(r) == 50) ? 0 : 1;
  295. r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.xy())); Error += (int(r) == 50) ? 0 : 1;
  296. r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy())); Error += (int(r) == 60) ? 0 : 1;
  297. // vec3
  298. glm::vec3 q, u, v;
  299. u = glm::vec3(1, 2, 3);
  300. v = glm::vec3(10, 20, 30);
  301. r = glm::dot(u, v); Error += (int(r) == 140) ? 0 : 1;
  302. r = glm::dot(u.xyz(), v.zyz()); Error += (int(r) == 160) ? 0 : 1;
  303. r = glm::dot(u, v.zyx()); Error += (int(r) == 100) ? 0 : 1;
  304. r = glm::dot(u.xyz(), v); Error += (int(r) == 140) ? 0 : 1;
  305. r = glm::dot(u.xy(), v.xy()); Error += (int(r) == 50) ? 0 : 1;
  306. // vec4
  307. glm::vec4 s, t;
  308. s = glm::vec4(1, 2, 3, 4);
  309. t = glm::vec4(10, 20, 30, 40);
  310. r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1;
  311. r = glm::dot(s.xyzw(), t.xyzw()); Error += (int(r) == 300) ? 0 : 1;
  312. r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1;
  313. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  314. return Error;
  315. }
  316. int test_vec3_swizzle_partial()
  317. {
  318. int Error = 0;
  319. #if(GLM_SUPPORT_SWIZZLE_OPERATOR())
  320. glm::vec3 A(1, 2, 3);
  321. {
  322. glm::vec3 B(A.xy, 3.0f);
  323. Error += A == B ? 0 : 1;
  324. }
  325. {
  326. glm::vec3 B(1.0f, A.yz);
  327. Error += A == B ? 0 : 1;
  328. }
  329. {
  330. glm::vec3 B(A.xyz);
  331. Error += A == B ? 0 : 1;
  332. }
  333. #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
  334. return Error;
  335. }
  336. int main()
  337. {
  338. int Error = 0;
  339. Error += test_vec3_ctor();
  340. Error += test_vec3_operators();
  341. Error += test_vec3_size();
  342. Error += test_vec3_swizzle3_2();
  343. Error += test_vec3_swizzle3_3();
  344. Error += test_vec3_swizzle_half();
  345. Error += test_vec3_swizzle_partial();
  346. Error += test_vec3_swizzle_operators();
  347. Error += test_vec3_swizzle_functions();
  348. printf("Errors: %d\n", Error);
  349. return Error;
  350. }