Home Explore Help
Sign In
cpp
/
3DSoftwareRenderer-DFSPR
mirror of https://github.com/Dawoodoz/DFPSR.git
2
0
Fork 0
Files Issues 0 Wiki
Branch: master
Branches Tags
3DSoftwareRende...
/
Source
/
test
/
tests
/
VectorTest.cpp

VectorTest.cpp 6.8 KB
Permalink History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125 
  1. 
    2. 

  2. #include "../testTools.h"
    3. 

  3. #include "../../DFPSR/math/UVector.h"
    4. 

  4. #include "../../DFPSR/math/IVector.h"
    5. 

  5. #include "../../DFPSR/math/LVector.h"
    6. 

  6. #include "../../DFPSR/math/FVector.h"
    7. 

  7. 

  8. START_TEST(Vector)
    9. 

  9. 	// Comparisons
    10. 

  10. 	ASSERT_EQUAL(UVector2D(64u, 23u), UVector2D(64u, 23u));
    11. 

  11. 	ASSERT_EQUAL(IVector2D(64, 23), IVector2D(64, 23));
    12. 

  12. 	ASSERT_EQUAL(LVector2D(64, 23), LVector2D(64, 23));
    13. 

  13. 	ASSERT_NEAR(FVector2D(64.0f, 23.0f), FVector2D(64.0f, 23.0f));
    14. 

  14. 	ASSERT_EQUAL(UVector3D(64u, 23u, 74u), UVector3D(64u, 23u, 74u));
    15. 

  15. 	ASSERT_EQUAL(IVector3D(64, 23, 74), IVector3D(64, 23, 74));
    16. 

  16. 	ASSERT_EQUAL(LVector3D(64, 23, 74), LVector3D(64, 23, 74));
    17. 

  17. 	ASSERT_NEAR(FVector3D(64.0f, 23.0f, 74.0f), FVector3D(64.0f, 23.0f, 74.0f));
    18. 

  18. 	ASSERT_EQUAL(UVector4D(64u, 23u, 74u, 1483u), UVector4D(64u, 23u, 74u, 1483u));
    19. 

  19. 	ASSERT_EQUAL(IVector4D(64, 23, 74, 1483), IVector4D(64, 23, 74, 1483));
    20. 

  20. 	ASSERT_EQUAL(LVector4D(64, 23, 74, 1483), LVector4D(64, 23, 74, 1483));
    21. 

  21. 	ASSERT_EQUAL(FVector4D(64.0f, 23.0f, 74.0f, 1483.0f), FVector4D(64.0f, 23.0f, 74.0f, 1483.0f));
    22. 

  22. 	// Construct from single element
    23. 

  23. 	ASSERT_EQUAL(UVector2D(58u), UVector2D(58u, 58u));
    24. 

  24. 	ASSERT_EQUAL(UVector3D(45u), UVector3D(45u, 45u, 45u));
    25. 

  25. 	ASSERT_EQUAL(UVector4D(98u), UVector4D(98u, 98u, 98u, 98u));
    26. 

  26. 	ASSERT_EQUAL(IVector2D(58), IVector2D(58, 58));
    27. 

  27. 	ASSERT_EQUAL(IVector3D(45), IVector3D(45, 45, 45));
    28. 

  28. 	ASSERT_EQUAL(IVector4D(98), IVector4D(98, 98, 98, 98));
    29. 

  29. 	ASSERT_EQUAL(LVector2D(58), LVector2D(58, 58));
    30. 

  30. 	ASSERT_EQUAL(LVector3D(45), LVector3D(45, 45, 45));
    31. 

  31. 	ASSERT_EQUAL(LVector4D(98), LVector4D(98, 98, 98, 98));
    32. 

  32. 	ASSERT_EQUAL(FVector2D(58.1f), FVector2D(58.1f, 58.1f));
    33. 

  33. 	ASSERT_EQUAL(FVector3D(45.2f), FVector3D(45.2f, 45.2f, 45.2f));
    34. 

  34. 	ASSERT_EQUAL(FVector4D(98.3f), FVector4D(98.3f, 98.3f, 98.3f, 98.3f));
    35. 

  35. 	// Access single element
    36. 

  36. 	ASSERT_EQUAL(UVector2D(12u, 34u)[0], 12u);
    37. 

  37. 	ASSERT_EQUAL(UVector2D(12u, 34u)[1], 34u);
    38. 

  38. 	ASSERT_EQUAL(UVector3D(12u, 34u, 56u)[0], 12u);
    39. 

  39. 	ASSERT_EQUAL(UVector3D(12u, 34u, 56u)[1], 34u);
    40. 

  40. 	ASSERT_EQUAL(UVector3D(12u, 34u, 56u)[2], 56u);
    41. 

  41. 	ASSERT_EQUAL(UVector4D(12u, 34u, 56u, 78u)[0], 12u);
    42. 

  42. 	ASSERT_EQUAL(UVector4D(12u, 34u, 56u, 78u)[1], 34u);
    43. 

  43. 	ASSERT_EQUAL(UVector4D(12u, 34u, 56u, 78u)[2], 56u);
    44. 

  44. 	ASSERT_EQUAL(UVector4D(12u, 34u, 56u, 78u)[3], 78u);
    45. 

  45. 	ASSERT_EQUAL(IVector2D(12, 34)[0], 12);
    46. 

  46. 	ASSERT_EQUAL(IVector2D(12, 34)[1], 34);
    47. 

  47. 	ASSERT_EQUAL(IVector3D(12, 34, 56)[0], 12);
    48. 

  48. 	ASSERT_EQUAL(IVector3D(12, 34, 56)[1], 34);
    49. 

  49. 	ASSERT_EQUAL(IVector3D(12, 34, 56)[2], 56);
    50. 

  50. 	ASSERT_EQUAL(IVector4D(12, 34, 56, 78)[0], 12);
    51. 

  51. 	ASSERT_EQUAL(IVector4D(12, 34, 56, 78)[1], 34);
    52. 

  52. 	ASSERT_EQUAL(IVector4D(12, 34, 56, 78)[2], 56);
    53. 

  53. 	ASSERT_EQUAL(IVector4D(12, 34, 56, 78)[3], 78);
    54. 

  54. 	ASSERT_EQUAL(LVector2D(12, 34)[0], 12);
    55. 

  55. 	ASSERT_EQUAL(LVector2D(12, 34)[1], 34);
    56. 

  56. 	ASSERT_EQUAL(LVector3D(12, 34, 56)[0], 12);
    57. 

  57. 	ASSERT_EQUAL(LVector3D(12, 34, 56)[1], 34);
    58. 

  58. 	ASSERT_EQUAL(LVector3D(12, 34, 56)[2], 56);
    59. 

  59. 	ASSERT_EQUAL(LVector4D(12, 34, 56, 78)[0], 12);
    60. 

  60. 	ASSERT_EQUAL(LVector4D(12, 34, 56, 78)[1], 34);
    61. 

  61. 	ASSERT_EQUAL(LVector4D(12, 34, 56, 78)[2], 56);
    62. 

  62. 	ASSERT_EQUAL(LVector4D(12, 34, 56, 78)[3], 78);
    63. 

  63. 	ASSERT_EQUAL(FVector2D(12.0f, 34.0f)[0], 12.0f);
    64. 

  64. 	ASSERT_EQUAL(FVector2D(12.0f, 34.0f)[1], 34.0f);
    65. 

  65. 	ASSERT_EQUAL(FVector3D(12.0f, 34.0f, 56.0f)[0], 12.0f);
    66. 

  66. 	ASSERT_EQUAL(FVector3D(12.0f, 34.0f, 56.0f)[1], 34.0f);
    67. 

  67. 	ASSERT_EQUAL(FVector3D(12.0f, 34.0f, 56.0f)[2], 56.0f);
    68. 

  68. 	ASSERT_EQUAL(FVector4D(12.0f, 34.0f, 56.0f, 78.0f)[0], 12.0f);
    69. 

  69. 	ASSERT_EQUAL(FVector4D(12.0f, 34.0f, 56.0f, 78.0f)[1], 34.0f);
    70. 

  70. 	ASSERT_EQUAL(FVector4D(12.0f, 34.0f, 56.0f, 78.0f)[2], 56.0f);
    71. 

  71. 	ASSERT_EQUAL(FVector4D(12.0f, 34.0f, 56.0f, 78.0f)[3], 78.0f);
    72. 

  72. 	// Math
    73. 

  73. 	ASSERT_EQUAL(UVector2D(12u, 34u) + UVector2D(8u, 6u), UVector2D(20u, 40u));
    74. 

  74. 	ASSERT_EQUAL(IVector2D(12, 34) + IVector2D(8, 6), IVector2D(20, 40));
    75. 

  75. 	ASSERT_EQUAL(LVector2D(12, 34) + LVector2D(8, 6), LVector2D(20, 40));
    76. 

  76. 	ASSERT_NEAR(FVector2D(12.0f, 34.0f) + FVector2D(8.0f, 6.0f), FVector2D(20.0f, 40.0f));
    77. 

  77. 	ASSERT_EQUAL(UVector2D(12u, 34u) + 4u, UVector2D(16u, 38u));
    78. 

  78. 	ASSERT_EQUAL(IVector2D(12, 34) + 4, IVector2D(16, 38));
    79. 

  79. 	ASSERT_EQUAL(LVector2D(12, 34) + 4, LVector2D(16, 38));
    80. 

  80. 	ASSERT_NEAR(FVector2D(12.0f, 34.0f) + 4.0f, FVector2D(16.0f, 38.0f));
    81. 

  81. 	ASSERT_EQUAL(100u + UVector2D(1u, 2u), UVector2D(101u, 102u));
    82. 

  82. 	ASSERT_EQUAL(100 + IVector2D(1, 2), IVector2D(101, 102));
    83. 

  83. 	ASSERT_EQUAL(100 + LVector2D(1, 2), LVector2D(101, 102));
    84. 

  84. 	ASSERT_NEAR(100.0f + FVector2D(1.0f, 2.0f), FVector2D(101.0f, 102.0f));
    85. 

  85. 	ASSERT_EQUAL(UVector2D(13u, 64u) - UVector2D(3u, 4u), UVector2D(10u, 60u));
    86. 

  86. 	ASSERT_EQUAL(IVector2D(13, 64) - IVector2D(3, 4), IVector2D(10, 60));
    87. 

  87. 	ASSERT_EQUAL(LVector2D(13, 64) - LVector2D(3, 4), LVector2D(10, 60));
    88. 

  88. 	ASSERT_NEAR(FVector2D(13.0f, 64.0f) - FVector2D(3.0f, 4.0f), FVector2D(10.0f, 60.0f));
    89. 

  89. 	ASSERT_EQUAL(UVector2D(37u, 38u) - 30u, UVector2D(7u, 8u));
    90. 

  90. 	ASSERT_EQUAL(IVector2D(37, 38) - 30, IVector2D(7, 8));
    91. 

  91. 	ASSERT_EQUAL(LVector2D(37, 38) - 30, LVector2D(7, 8));
    92. 

  92. 	ASSERT_NEAR(FVector2D(37.0f, 38.0f) - 30.0f, FVector2D(7.0f, 8.0f));
    93. 

  93. 	ASSERT_EQUAL(10u - UVector2D(4u, 7u), UVector2D(6u, 3u));
    94. 

  94. 	ASSERT_EQUAL(10 - IVector2D(4, 7), IVector2D(6, 3));
    95. 

  95. 	ASSERT_EQUAL(10 - LVector2D(4, 7), LVector2D(6, 3));
    96. 

  96. 	ASSERT_NEAR(10.0f - FVector2D(4.0f, 7.0f), FVector2D(6.0f, 3.0f));
    97. 

  97. 	ASSERT_EQUAL(IVector2D(3, -8) * IVector2D(2, -2), IVector2D(6, 16));
    98. 

  98. 	ASSERT_EQUAL(LVector2D(3, -8) * LVector2D(2, -2), LVector2D(6, 16));
    99. 

  99. 	ASSERT_NEAR(FVector2D(3.0f, -8.0f) * FVector2D(2.0f, -2.0f), FVector2D(6.0f, 16.0f));
    100. 

  100. 	ASSERT_EQUAL(UVector2D(2u, 3u) * 5u, UVector2D(10u, 15u));
    101. 

  101. 	ASSERT_EQUAL(IVector2D(2, 3) * 5, IVector2D(10, 15));
    102. 

  102. 	ASSERT_EQUAL(LVector2D(2, 3) * 5, LVector2D(10, 15));
    103. 

  103. 	ASSERT_NEAR(FVector2D(2.0f, 3.0f) * 5.0f, FVector2D(10.0f, 15.0f));
    104. 

  104. 	ASSERT_EQUAL(7 * IVector2D(1, -1), IVector2D(7, -7));
    105. 

  105. 	ASSERT_EQUAL(7 * LVector2D(1, -1), LVector2D(7, -7));
    106. 

  106. 	ASSERT_NEAR(7.0f * FVector2D(1.0f, -1.0f), FVector2D(7.0f, -7.0f));
    107. 

  107. 	ASSERT_EQUAL(UVector2D(20u, 40u) / UVector2D(2u, 4u), UVector2D(10u, 10u));
    108. 

  108. 	ASSERT_EQUAL(IVector2D(20, 40) / IVector2D(2, 4), IVector2D(10, 10));
    109. 

  109. 	ASSERT_EQUAL(LVector2D(20, 40) / LVector2D(2, 4), LVector2D(10, 10));
    110. 

  110. 	ASSERT_NEAR(FVector2D(20.0f, 40.0f) / FVector2D(2.0f, 4.0f), FVector2D(10.0f, 10.0f));
    111. 

  111. 	ASSERT_EQUAL(UVector2D(20u, 40u) / 10u, UVector2D(2u, 4u));
    112. 

  112. 	ASSERT_EQUAL(IVector2D(20, 40) / 10, IVector2D(2, 4));
    113. 

  113. 	ASSERT_EQUAL(LVector2D(20, 40) / 10, LVector2D(2, 4));
    114. 

  114. 	ASSERT_NEAR(FVector2D(20.0f, 40.0f) / 10.0f, FVector2D(2.0f, 4.0f));
    115. 

  115. 	ASSERT_EQUAL(12u / UVector2D(3u, 4u), UVector2D(4u, 3u));
    116. 

  116. 	ASSERT_EQUAL(12 / IVector2D(3, 4), IVector2D(4, 3));
    117. 

  117. 	ASSERT_EQUAL(12 / LVector2D(3, 4), LVector2D(4, 3));
    118. 

  118. 	ASSERT_NEAR(12.0f / FVector2D(3.0f, 4.0f), FVector2D(4.0f, 3.0f));
    119. 

  119. 	// Linear algebra
    120. 

  120. 	ASSERT_EQUAL(length(FVector3D(1.0f, 0.0f, 0.0f)), 1.0f);
    121. 

  121. 	ASSERT_EQUAL(length(FVector3D(0.0f, 2.0f, 0.0f)), 2.0f);
    122. 

  122. 	ASSERT_EQUAL(length(FVector3D(0.0f, 0.0f, 3.0f)), 3.0f);
    123. 

  123. 	ASSERT_EQUAL(length(FVector3D(1.0f, 1.0f, 0.0f)), 1.41421356f);
    124. 

  124. END_TEST
    125. 

  125.