tuple_test.cpp 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219
  1. /*
  2. * DoRayMe - a quick and dirty Raytracer
  3. * Tuples unit tests
  4. *
  5. * Created by Manoël Trapier
  6. * Copyright (c) 2020 986-Studio.
  7. *
  8. */
  9. #include <tuple.h>
  10. #include <math.h>
  11. #include <gtest/gtest.h>
  12. TEST(TupleTest, Tuple_With_w_equal_1_and_is_point)
  13. {
  14. Tuple a = Tuple(4.3, -4.2, 3.1, 1.0);
  15. ASSERT_EQ(a.x, 4.3);
  16. ASSERT_EQ(a.y, -4.2);
  17. ASSERT_EQ(a.z, 3.1);
  18. ASSERT_EQ(a.w, 1.0);
  19. ASSERT_TRUE(a.isPoint());
  20. ASSERT_FALSE(a.isVector());
  21. }
  22. TEST(TupleTest, Two_tuples_are_equal)
  23. {
  24. Tuple a = Tuple(1, 2, 3, 4);
  25. Tuple b = Tuple(1, 2, 3, 4);
  26. Tuple c = Tuple(4, 3, 2, 1);
  27. Tuple d = Tuple(1, 2, 3, 5);
  28. Tuple e = Tuple(1, 2, 5, 5);
  29. Tuple f = Tuple(1, 5, 5, 5);
  30. ASSERT_EQ(a, b);
  31. ASSERT_NE(a, c);
  32. ASSERT_NE(a, d);
  33. ASSERT_NE(a, e);
  34. ASSERT_NE(a, f);
  35. }
  36. TEST(TupleTest, Tuple_With_w_equal_0_and_is_vector)
  37. {
  38. Tuple a = Tuple(4.3, -4.2, 3.1, 0.0);
  39. ASSERT_EQ(a.x, 4.3);
  40. ASSERT_EQ(a.y, -4.2);
  41. ASSERT_EQ(a.z, 3.1);
  42. ASSERT_EQ(a.w, 0.0);
  43. ASSERT_FALSE(a.isPoint());
  44. ASSERT_TRUE(a.isVector());
  45. }
  46. TEST(TupleTest, Point_create_tuples_with_w_equal_1)
  47. {
  48. Tuple a = Point(4, -4, 3);
  49. ASSERT_EQ(a, Tuple(4, -4, 3, 1));
  50. }
  51. TEST(TupleTest, Vector_create_tuples_with_w_equal_0)
  52. {
  53. Tuple a = Vector(4, -4, 3);
  54. ASSERT_EQ(a, Tuple(4, -4, 3, 0));
  55. }
  56. TEST(TupleTest, Adding_two_tuples)
  57. {
  58. Tuple a1 = Tuple(3, -2, 5, 1);
  59. Tuple a2 = Tuple(-2, 3, 1, 0);
  60. ASSERT_EQ(a1 + a2, Tuple(1, 1, 6, 1));
  61. }
  62. TEST(TupleTest, Substracting_two_points)
  63. {
  64. Point p1 = Point(3, 2, 1);
  65. Point p2 = Point(5, 6, 7);
  66. ASSERT_EQ(p1 - p2, Vector(-2, -4, -6));
  67. }
  68. TEST(TupleTest, Substracting_a_vector_from_a_point)
  69. {
  70. Point p = Point(3, 2, 1);
  71. Vector v = Vector(5, 6, 7);
  72. ASSERT_EQ(p - v, Point(-2, -4, -6));
  73. }
  74. TEST(TupleTest, Substracting_two_vectors)
  75. {
  76. Vector v1 = Vector(3, 2, 1);
  77. Vector v2 = Vector(5, 6, 7);
  78. ASSERT_EQ(v1 - v2, Vector(-2, -4, -6));
  79. }
  80. TEST(TupleTest, Substracting_a_vector_from_zero_vector)
  81. {
  82. Vector zero = Vector(0, 0, 0);
  83. Vector v = Vector(1, -2, 3);
  84. ASSERT_EQ(zero - v, Vector(-1, 2, -3));
  85. }
  86. TEST(TupleTest, Negating_a_tuple)
  87. {
  88. Tuple a = Tuple(1, -2, 3, -4);
  89. ASSERT_EQ(-a, Tuple(-1, 2, -3, 4));
  90. }
  91. TEST(TupleTest, Multiplying_a_tuple_by_a_scalar)
  92. {
  93. Tuple a = Tuple(1, -2, 3, -4);
  94. ASSERT_EQ(a * 3.5, Tuple(3.5, -7, 10.5, -14));
  95. }
  96. TEST(TupleTest, Multiplying_a_tuple_by_a_fraction)
  97. {
  98. Tuple a = Tuple(1, -2, 3, -4);
  99. ASSERT_EQ(a * 0.5, Tuple(0.5, -1, 1.5, -2));
  100. }
  101. TEST(TupleTest, Dividing_a_tuple_by_a_scalar)
  102. {
  103. Tuple a = Tuple(1, -2, 3, -4);
  104. ASSERT_EQ(a / 2, Tuple(0.5, -1, 1.5, -2));
  105. }
  106. TEST(TupleTest, Computing_the_magnitude_of_vector_1_0_0)
  107. {
  108. Vector v = Vector(1, 0, 0);
  109. ASSERT_EQ(v.magnitude(), 1);
  110. }
  111. TEST(TupleTest, Computing_the_magnitude_of_vector_0_1_0)
  112. {
  113. Vector v = Vector(0, 1, 0);
  114. ASSERT_EQ(v.magnitude(), 1);
  115. }
  116. TEST(TupleTest, Computing_the_magnitude_of_vector_0_0_1)
  117. {
  118. Vector v = Vector(0, 0, 1);
  119. ASSERT_EQ(v.magnitude(), 1);
  120. }
  121. TEST(TupleTest, Computing_the_magnitude_of_vector_1_2_3)
  122. {
  123. Vector v = Vector(1, 2, 3);
  124. ASSERT_EQ(v.magnitude(), sqrt(14));
  125. }
  126. TEST(TupleTest, Computing_the_magnitude_of_vector_n1_n2_n3)
  127. {
  128. Vector v = Vector(-1, -2, -3);
  129. ASSERT_EQ(v.magnitude(), sqrt(14));
  130. }
  131. TEST(TupleTest, Nomilise_vector_4_0_0_give_1_0_0)
  132. {
  133. Vector v = Vector(4, 0, 0);
  134. ASSERT_EQ(v.normalise(), Vector(1, 0, 0));
  135. }
  136. TEST(TupleTest, Nomilise_vector_1_2_3)
  137. {
  138. Vector v = Vector(1, 2, 3);
  139. ASSERT_EQ(v.normalise(), Vector(1 / sqrt(14), 2 / sqrt(14), 3 / sqrt(14)));
  140. }
  141. TEST(TupleTest, Dot_product_of_two_tuples)
  142. {
  143. Vector a = Vector(1, 2, 3);
  144. Vector b = Vector(2, 3, 4);
  145. ASSERT_EQ(a.dot(b), 20);
  146. }
  147. TEST(TupleTest, Cross_product_of_two_vector)
  148. {
  149. Vector a = Vector(1, 2, 3);
  150. Vector b = Vector(2, 3, 4);
  151. ASSERT_EQ(a.cross(b), Vector(-1, 2, -1));
  152. ASSERT_EQ(b.cross(a), Vector(1, -2, 1));
  153. }
  154. TEST(TupleTest, Reflecting_a_vector_approaching_at_45)
  155. {
  156. Vector v = Vector(1, -1, 0); /* Vector */
  157. Vector n = Vector(0, 1, 0); /* Normal */
  158. Tuple r = v.reflect(n);
  159. ASSERT_EQ(r, Vector(1, 1, 0));
  160. }
  161. TEST(TupleTest, Reflecting_a_vector_off_a_slanted_surface)
  162. {
  163. Vector v = Vector(0, -1, 0); /* Vector */
  164. Vector n = Vector(sqrt(2)/2, sqrt(2)/2, 0); /* Normal */
  165. Tuple r = v.reflect(n);
  166. ASSERT_EQ(r, Vector(1, 0, 0));
  167. }