Fix Vector2 multiplication operator behavior

RobLoach · RobLoach · commit 9de4e175e429 · 2021-12-24T15:05:45.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,12 +11,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Sound::IsLoaded()`
 - `Music::IsLoaded()`
 - Shader example
-- `raylib::DrawText()` for `std::string` support
-- `raylib::DrawTextEx()` for `std::string` support
-- `raylib::DrawTextPro()` for `std::string` support
+- Function overrides for `std::string` support
+    - `raylib::DrawText()`
+    - `raylib::DrawTextEx()`
+    - `raylib::DrawTextPro()`
+    - `raylib::TextSubtext()`
+    - `raylib::TextReplace()`
+    - `raylib::TextInsert()`
+    - `raylib::TextAppend()`
+    - `raylib::TextFindIndex()`
+    - `raylib::TextToUpper()`
+    - `raylib::TextToLower()`
+    - `raylib::TextToPascal()`
+    - `raylib::TextToInteger()`
 
 ### Fixed
 - Shader constructor
+- Vector2 muliplication operator behavior ([#155](https://github.com/RobLoach/raylib-cpp/issues/155))
 
 ### Changed
 - Merged `Text.hpp` into `Functions.hpp`
diff --git a/include/Vector2.hpp b/include/Vector2.hpp
@@ -41,62 +41,56 @@ class Vector2 : public ::Vector2 {
         return Vector2Add(*this, vector2);
     }
 
-    Vector2 operator+(const ::Vector2& vector2) {
+    Vector2 operator+(const ::Vector2& vector2) const {
         return Vector2Add(*this, vector2);
     }
 
     Vector2 Subtract(const ::Vector2& vector2) const {
         return Vector2Subtract(*this, vector2);
     }
 
-    Vector2 operator-(const ::Vector2& vector2) {
+    Vector2 operator-(const ::Vector2& vector2) const {
         return Vector2Subtract(*this, vector2);
     }
 
     Vector2 Negate() const {
         return Vector2Negate(*this);
     }
 
-    Vector2 operator-() {
+    Vector2 operator-() const {
         return Vector2Negate(*this);
     }
 
     Vector2 Multiply(const ::Vector2& vector2) const {
         return Vector2Multiply(*this, vector2);
     }
 
-    Vector2 operator*(const ::Vector2& vector2) {
+    Vector2 operator*(const ::Vector2& vector2) const {
         return Vector2Multiply(*this, vector2);
     }
 
     Vector2 Scale(const float scale) const {
         return Vector2Scale(*this, scale);
     }
 
-    Vector2 operator*(const float scale) {
+    Vector2 operator*(const float scale) const {
         return Vector2Scale(*this, scale);
     }
 
     Vector2 Divide(const ::Vector2& vector2) const {
         return Vector2Divide(*this, vector2);
     }
 
-    Vector2 operator/(const ::Vector2& vector2) {
+    Vector2 operator/(const ::Vector2& vector2) const {
         return Vector2Divide(*this, vector2);
     }
 
-    Vector2& Divide(const float div) {
-        x /= div;
-        y /= div;
-
-        return *this;
+    Vector2 Divide(const float div) const {
+        return ::Vector2{x / div, y / div};
     }
 
-    Vector2& operator/(const float div) {
-        x /= div;
-        y /= div;
-
-        return *this;
+    Vector2 operator/(const float div) const {
+        return Divide(div);
     }
 
     Vector2& operator+=(const ::Vector2& vector2) {
diff --git a/include/Vector3.hpp b/include/Vector3.hpp
@@ -68,39 +68,35 @@ class Vector3 : public ::Vector3 {
         return Vector3Negate(*this);
     }
 
-    Vector3 Multiply(const ::Vector3& vector3) {
+    Vector3 Multiply(const ::Vector3& vector3) const {
         return Vector3Multiply(*this, vector3);
     }
 
-    Vector3 operator*(const ::Vector3& vector3) {
+    Vector3 operator*(const ::Vector3& vector3) const {
         return Vector3Multiply(*this, vector3);
     }
 
-    Vector3 Scale(const float scale) {
+    Vector3 Scale(const float scale) const {
         return Vector3Scale(*this, scale);
     }
 
-    Vector3 operator*(const float scale) {
+    Vector3 operator*(const float scale) const {
         return Vector3Scale(*this, scale);
     }
 
-    Vector3 Divide(const ::Vector3& vector3) {
+    Vector3 Divide(const ::Vector3& vector3) const {
         return Vector3Divide(*this, vector3);
     }
 
-    Vector3 operator/(const ::Vector3& vector3) {
+    Vector3 operator/(const ::Vector3& vector3) const {
         return Vector3Divide(*this, vector3);
     }
 
-    Vector3& Divide(const float div) {
-        x /= div;
-        y /= div;
-        z /= div;
-
-        return *this;
+    Vector3 Divide(const float div) const {
+        return ::Vector3{x / div, y / div, z / div};
     }
 
-    Vector3 operator/(const float div) {
+    Vector3 operator/(const float div) const {
         return Divide(div);
     }
 
@@ -149,43 +145,43 @@ class Vector3 : public ::Vector3 {
         return Vector3Length(*this);
     }
 
-    Vector3 Normalize() {
+    Vector3 Normalize() const {
         return Vector3Normalize(*this);
     }
 
     float DotProduct(const ::Vector3& vector3) {
         return Vector3DotProduct(*this, vector3);
     }
 
-    float Distance(const ::Vector3& vector3) {
+    float Distance(const ::Vector3& vector3) const {
         return Vector3Distance(*this, vector3);
     }
 
-    Vector3 Lerp(const ::Vector3& vector3, const float amount) {
+    Vector3 Lerp(const ::Vector3& vector3, const float amount) const {
         return Vector3Lerp(*this, vector3, amount);
     }
 
-    Vector3 CrossProduct(const ::Vector3& vector3) {
+    Vector3 CrossProduct(const ::Vector3& vector3) const {
         return Vector3CrossProduct(*this, vector3);
     }
 
-    Vector3 Perpendicular() {
+    Vector3 Perpendicular() const {
         return Vector3Perpendicular(*this);
     }
 
     void OrthoNormalize(::Vector3* vector3) {
         Vector3OrthoNormalize(this, vector3);
     }
 
-    Vector3 Transform(const ::Matrix& matrix) {
+    Vector3 Transform(const ::Matrix& matrix) const {
         return Vector3Transform(*this, matrix);
     }
 
     Vector3 RotateByQuaternion(const ::Quaternion& quaternion) {
         return Vector3RotateByQuaternion(*this, quaternion);
     }
 
-    Vector3 Reflect(const ::Vector3& normal) {
+    Vector3 Reflect(const ::Vector3& normal) const {
         return Vector3Reflect(*this, normal);
     }
 
diff --git a/include/Vector4.hpp b/include/Vector4.hpp
@@ -57,39 +57,39 @@ class Vector4 : public ::Vector4 {
     }
 
 #ifndef RAYLIB_CPP_NO_MATH
-    Vector4 Multiply(const ::Vector4& vector4) {
+    Vector4 Multiply(const ::Vector4& vector4) const {
         return QuaternionMultiply(*this, vector4);
     }
 
-    Vector4 operator*(const ::Vector4& vector4) {
+    Vector4 operator*(const ::Vector4& vector4) const {
         return QuaternionMultiply(*this, vector4);
     }
 
-    Vector4 Lerp(const ::Vector4& vector4, float amount) {
+    Vector4 Lerp(const ::Vector4& vector4, float amount) const {
         return QuaternionLerp(*this, vector4, amount);
     }
 
-    Vector4 Nlerp(const ::Vector4& vector4, float amount) {
+    Vector4 Nlerp(const ::Vector4& vector4, float amount) const {
         return QuaternionNlerp(*this, vector4, amount);
     }
 
-    Vector4 Slerp(const ::Vector4& vector4, float amount) {
+    Vector4 Slerp(const ::Vector4& vector4, float amount) const {
         return QuaternionSlerp(*this, vector4, amount);
     }
 
-    Matrix ToMatrix() {
+    Matrix ToMatrix() const {
         return QuaternionToMatrix(*this);
     }
 
     float Length() const {
         return QuaternionLength(*this);
     }
 
-    Vector4 Normalize() {
+    Vector4 Normalize() const {
         return QuaternionNormalize(*this);
     }
 
-    Vector4 Invert() {
+    Vector4 Invert() const {
         return QuaternionInvert(*this);
     }
 
diff --git a/tests/raylib_test.cpp b/tests/raylib_test.cpp
@@ -25,6 +25,16 @@ int main(int argc, char *argv[]) {
         position += speed;
         assert(position.x == 310);
         assert(raylib::Window::IsReady() == false);
+
+        raylib::Vector2 size{50,50};
+        raylib::Vector2 halfsize = size / 2.0f;
+
+        assert(size.x == 50);
+        assert(halfsize.x == 25);
+
+        raylib::Vector2 doublesize = size * 2.0f;
+        assert(size.x == 50);
+        assert(doublesize.x == 100);
     }
 
     // Color

Original file line number	Diff line number	Diff line change
`@@ -41,62 +41,56 @@ class Vector2 : public ::Vector2 {`
`41`	`41`	`return Vector2Add(*this, vector2);`
`42`	`42`	`}`
`43`	`43`
`44`		`- Vector2 operator+(const ::Vector2& vector2) {`
	`44`	`+ Vector2 operator+(const ::Vector2& vector2) const {`
`45`	`45`	`return Vector2Add(*this, vector2);`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`Vector2 Subtract(const ::Vector2& vector2) const {`
`49`	`49`	`return Vector2Subtract(*this, vector2);`
`50`	`50`	`}`
`51`	`51`
`52`		`- Vector2 operator-(const ::Vector2& vector2) {`
	`52`	`+ Vector2 operator-(const ::Vector2& vector2) const {`
`53`	`53`	`return Vector2Subtract(*this, vector2);`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`Vector2 Negate() const {`
`57`	`57`	`return Vector2Negate(*this);`
`58`	`58`	`}`
`59`	`59`
`60`		`- Vector2 operator-() {`
	`60`	`+ Vector2 operator-() const {`
`61`	`61`	`return Vector2Negate(*this);`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`Vector2 Multiply(const ::Vector2& vector2) const {`
`65`	`65`	`return Vector2Multiply(*this, vector2);`
`66`	`66`	`}`
`67`	`67`
`68`		`- Vector2 operator*(const ::Vector2& vector2) {`
	`68`	`+ Vector2 operator*(const ::Vector2& vector2) const {`
`69`	`69`	`return Vector2Multiply(*this, vector2);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`Vector2 Scale(const float scale) const {`
`73`	`73`	`return Vector2Scale(*this, scale);`
`74`	`74`	`}`
`75`	`75`
`76`		`- Vector2 operator*(const float scale) {`
	`76`	`+ Vector2 operator*(const float scale) const {`
`77`	`77`	`return Vector2Scale(*this, scale);`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`Vector2 Divide(const ::Vector2& vector2) const {`
`81`	`81`	`return Vector2Divide(*this, vector2);`
`82`	`82`	`}`
`83`	`83`
`84`		`- Vector2 operator/(const ::Vector2& vector2) {`
	`84`	`+ Vector2 operator/(const ::Vector2& vector2) const {`
`85`	`85`	`return Vector2Divide(*this, vector2);`
`86`	`86`	`}`
`87`	`87`
`88`		`- Vector2& Divide(const float div) {`
`89`		`- x /= div;`
`90`		`- y /= div;`
`91`		`-`
`92`		`- return *this;`
	`88`	`+ Vector2 Divide(const float div) const {`
	`89`	`+ return ::Vector2{x / div, y / div};`
`93`	`90`	`}`
`94`	`91`
`95`		`- Vector2& operator/(const float div) {`
`96`		`- x /= div;`
`97`		`- y /= div;`
`98`		`-`
`99`		`- return *this;`
	`92`	`+ Vector2 operator/(const float div) const {`
	`93`	`+ return Divide(div);`
`100`	`94`	`}`
`101`	`95`
`102`	`96`	`Vector2& operator+=(const ::Vector2& vector2) {`
Original file line number	Diff line number	Diff line change
`@@ -68,39 +68,35 @@ class Vector3 : public ::Vector3 {`
`68`	`68`	`return Vector3Negate(*this);`
`69`	`69`	`}`
`70`	`70`
`71`		`- Vector3 Multiply(const ::Vector3& vector3) {`
	`71`	`+ Vector3 Multiply(const ::Vector3& vector3) const {`
`72`	`72`	`return Vector3Multiply(*this, vector3);`
`73`	`73`	`}`
`74`	`74`
`75`		`- Vector3 operator*(const ::Vector3& vector3) {`
	`75`	`+ Vector3 operator*(const ::Vector3& vector3) const {`
`76`	`76`	`return Vector3Multiply(*this, vector3);`
`77`	`77`	`}`
`78`	`78`
`79`		`- Vector3 Scale(const float scale) {`
	`79`	`+ Vector3 Scale(const float scale) const {`
`80`	`80`	`return Vector3Scale(*this, scale);`
`81`	`81`	`}`
`82`	`82`
`83`		`- Vector3 operator*(const float scale) {`
	`83`	`+ Vector3 operator*(const float scale) const {`
`84`	`84`	`return Vector3Scale(*this, scale);`
`85`	`85`	`}`
`86`	`86`
`87`		`- Vector3 Divide(const ::Vector3& vector3) {`
	`87`	`+ Vector3 Divide(const ::Vector3& vector3) const {`
`88`	`88`	`return Vector3Divide(*this, vector3);`
`89`	`89`	`}`
`90`	`90`
`91`		`- Vector3 operator/(const ::Vector3& vector3) {`
	`91`	`+ Vector3 operator/(const ::Vector3& vector3) const {`
`92`	`92`	`return Vector3Divide(*this, vector3);`
`93`	`93`	`}`
`94`	`94`
`95`		`- Vector3& Divide(const float div) {`
`96`		`- x /= div;`
`97`		`- y /= div;`
`98`		`- z /= div;`
`99`		`-`
`100`		`- return *this;`
	`95`	`+ Vector3 Divide(const float div) const {`
	`96`	`+ return ::Vector3{x / div, y / div, z / div};`
`101`	`97`	`}`
`102`	`98`
`103`		`- Vector3 operator/(const float div) {`
	`99`	`+ Vector3 operator/(const float div) const {`
`104`	`100`	`return Divide(div);`
`105`	`101`	`}`
`106`	`102`
`@@ -149,43 +145,43 @@ class Vector3 : public ::Vector3 {`
`149`	`145`	`return Vector3Length(*this);`
`150`	`146`	`}`
`151`	`147`
`152`		`- Vector3 Normalize() {`
	`148`	`+ Vector3 Normalize() const {`
`153`	`149`	`return Vector3Normalize(*this);`
`154`	`150`	`}`
`155`	`151`
`156`	`152`	`float DotProduct(const ::Vector3& vector3) {`
`157`	`153`	`return Vector3DotProduct(*this, vector3);`
`158`	`154`	`}`
`159`	`155`
`160`		`- float Distance(const ::Vector3& vector3) {`
	`156`	`+ float Distance(const ::Vector3& vector3) const {`
`161`	`157`	`return Vector3Distance(*this, vector3);`
`162`	`158`	`}`
`163`	`159`
`164`		`- Vector3 Lerp(const ::Vector3& vector3, const float amount) {`
	`160`	`+ Vector3 Lerp(const ::Vector3& vector3, const float amount) const {`
`165`	`161`	`return Vector3Lerp(*this, vector3, amount);`
`166`	`162`	`}`
`167`	`163`
`168`		`- Vector3 CrossProduct(const ::Vector3& vector3) {`
	`164`	`+ Vector3 CrossProduct(const ::Vector3& vector3) const {`
`169`	`165`	`return Vector3CrossProduct(*this, vector3);`
`170`	`166`	`}`
`171`	`167`
`172`		`- Vector3 Perpendicular() {`
	`168`	`+ Vector3 Perpendicular() const {`
`173`	`169`	`return Vector3Perpendicular(*this);`
`174`	`170`	`}`
`175`	`171`
`176`	`172`	`void OrthoNormalize(::Vector3* vector3) {`
`177`	`173`	`Vector3OrthoNormalize(this, vector3);`
`178`	`174`	`}`
`179`	`175`
`180`		`- Vector3 Transform(const ::Matrix& matrix) {`
	`176`	`+ Vector3 Transform(const ::Matrix& matrix) const {`
`181`	`177`	`return Vector3Transform(*this, matrix);`
`182`	`178`	`}`
`183`	`179`
`184`	`180`	`Vector3 RotateByQuaternion(const ::Quaternion& quaternion) {`
`185`	`181`	`return Vector3RotateByQuaternion(*this, quaternion);`
`186`	`182`	`}`
`187`	`183`
`188`		`- Vector3 Reflect(const ::Vector3& normal) {`
	`184`	`+ Vector3 Reflect(const ::Vector3& normal) const {`
`189`	`185`	`return Vector3Reflect(*this, normal);`
`190`	`186`	`}`
`191`	`187`
Original file line number	Diff line number	Diff line change
`@@ -57,39 +57,39 @@ class Vector4 : public ::Vector4 {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`#ifndef RAYLIB_CPP_NO_MATH`
`60`		`- Vector4 Multiply(const ::Vector4& vector4) {`
	`60`	`+ Vector4 Multiply(const ::Vector4& vector4) const {`
`61`	`61`	`return QuaternionMultiply(*this, vector4);`
`62`	`62`	`}`
`63`	`63`
`64`		`- Vector4 operator*(const ::Vector4& vector4) {`
	`64`	`+ Vector4 operator*(const ::Vector4& vector4) const {`
`65`	`65`	`return QuaternionMultiply(*this, vector4);`
`66`	`66`	`}`
`67`	`67`
`68`		`- Vector4 Lerp(const ::Vector4& vector4, float amount) {`
	`68`	`+ Vector4 Lerp(const ::Vector4& vector4, float amount) const {`
`69`	`69`	`return QuaternionLerp(*this, vector4, amount);`
`70`	`70`	`}`
`71`	`71`
`72`		`- Vector4 Nlerp(const ::Vector4& vector4, float amount) {`
	`72`	`+ Vector4 Nlerp(const ::Vector4& vector4, float amount) const {`
`73`	`73`	`return QuaternionNlerp(*this, vector4, amount);`
`74`	`74`	`}`
`75`	`75`
`76`		`- Vector4 Slerp(const ::Vector4& vector4, float amount) {`
	`76`	`+ Vector4 Slerp(const ::Vector4& vector4, float amount) const {`
`77`	`77`	`return QuaternionSlerp(*this, vector4, amount);`
`78`	`78`	`}`
`79`	`79`
`80`		`- Matrix ToMatrix() {`
	`80`	`+ Matrix ToMatrix() const {`
`81`	`81`	`return QuaternionToMatrix(*this);`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`float Length() const {`
`85`	`85`	`return QuaternionLength(*this);`
`86`	`86`	`}`
`87`	`87`
`88`		`- Vector4 Normalize() {`
	`88`	`+ Vector4 Normalize() const {`
`89`	`89`	`return QuaternionNormalize(*this);`
`90`	`90`	`}`
`91`	`91`
`92`		`- Vector4 Invert() {`
	`92`	`+ Vector4 Invert() const {`
`93`	`93`	`return QuaternionInvert(*this);`
`94`	`94`	`}`
`95`	`95`