1 float Vector3::DotProduct(const Vector3 &vec) const {

2 return x * vec.x + y * vec.y + z * vec.z;

3 }

4

5 float DotProduct(const Vector3 &vec1, const Vector3 &vec2) {

6 return vec1.x * vec2.x + vec1.y * vec2.y + vec1.z * vec2.z;

7 }

8

9 Vector3 Vector3::CrossProduct(const Vector3 &vec) const {

10 return Vector3(y * vec.z - z * vec.y, z * vec.x - x * vec.z, x * vec.y - y * vec.x);

11 }

12

13 Vector3 CrossProduct(const Vector3 &vec1, const Vector3 &vec2) {

14 return Vector3(vec1.y * vec2.z - vec1.z * vec2.y, vec1.z * vec2.x - vec1.x * vec2.z, vec1.x * vec2.y - vec1.y * vec2.x);

15 }

16

17 Vector3 Vector3::operator +(const Vector3 &vec) const {

18 return Vector3(x + vec.x, y + vec.y, z + vec.z);

19 }

20

21 Vector3 Vector3::operator -(const Vector3 &vec) const {

22 return Vector3(x - vec.x, y - vec.y, z - vec.z);

23 }

24

25 Vector3 Vector3::operator *(float scalar) const {

26 return Vector3(x * scalar, y * scalar, z * scalar);

27 }

28

29 Vector3 Vector3::operator /(float scalar) const {

30 return Vector3(x / scalar, y / scalar, z / scalar);

31 }

32

33 void Vector3::operator +=(const Vector3 &vec) {

34 x += vec.x;

35 y += vec.y;

36 z += vec.z;

37 }

38

39 void Vector3::operator -=(const Vector3 &vec) {

40 x -= vec.x;

41 y -= vec.y;

42 z -= vec.z;

43 }

44

45 void Vector3::operator *=(float scalar) {

46 x *= scalar;

47 y *= scalar;

48 z *= scalar;

49 }

50

51 void Vector3::operator /=(float scalar) {

52 x /= scalar;

53 y /= scalar;

54 z /= scalar;

55 }

56

57 Vector3 Vector3::operator -() const {

58 return Vector3(-x, -y, -z);

59 }

60

61 bool Vector3::operator >(const Vector3 &vec) const {

62 return LengthSq() > vec.LengthSq();

63 }

64

65 bool Vector3::operator <(const Vector3 &vec) const {

66 return LengthSq() < vec.LengthSq();

67 }

68

69 bool Vector3::operator >(float len) const {

70 return LengthSq() > len;

71 }

72

73 bool Vector3::operator <(float len) const {

74 return LengthSq() < len;

75 }

76

77 bool Vector3::operator ==(const Vector3 &vec) const {

78 return ((*this - vec).Length() < XSmallNumber);

79 }

80

81 bool Vector3::operator ==(float len) const {

82 return ((this->Length() - len) < XSmallNumber);

83 }

84

85 Vector3::operator Vector2() const {

86 return Vector2(x, y);

87 }

88

89 Vector3::operator Vector4() const {

90 return Vector4(x, y, z, 1.0f);

91 }

92

93

94 float Vector3::Length() const {

95 return (float)sqrt(x*x + y*y + z*z);

96 }

97

98 float Vector3::LengthSq() const {

99 return x*x + y*y + z*z;

100 }

101

102 void Vector3::Normalize() {

103 float len = (float)sqrt(x*x + y*y + z*z);

104 x /= len;

105 y /= len;

106 z /= len;

107 }

108

109 Vector3 Vector3::Normalized() const {

110 float len = (float)sqrt(x*x + y*y + z*z);

111 return Vector3(x / len, y / len, z / len);

112 }

113

114 Vector3 Vector3::Reflection(const Vector3 &normal) const {

115 return normal * this->DotProduct(normal) * 2.0f - *this;

116 }